From 753c7be5c28f2749a0b4a374a3cfbc6936a95578 Mon Sep 17 00:00:00 2001 From: Kieron Lanning Date: Mon, 16 Nov 2026 08:12:17 +0000 Subject: [PATCH 1/3] build: move the shared Justfile recipes into .build/just modules --- .build/just/bump-version.ts | 62 ++++++++++++ .build/just/dotnet.just | 53 ++++++++++ .build/just/env.just | 56 +++++++++++ .build/just/index.just | 41 ++++++++ .build/just/purview-build-nuget.just | 30 ++++++ .build/just/purview-build.just | 24 +++++ .build/just/skills.just | 52 ++++++++++ .build/just/utilities.just | 44 +++++++++ .build/just/version.just | 28 ++++++ AGENTS.md | 13 ++- Justfile | 143 +++++++-------------------- 11 files changed, 433 insertions(+), 113 deletions(-) create mode 100644 .build/just/bump-version.ts create mode 100644 .build/just/dotnet.just create mode 100644 .build/just/env.just create mode 100644 .build/just/index.just create mode 100644 .build/just/purview-build-nuget.just create mode 100644 .build/just/purview-build.just create mode 100644 .build/just/skills.just create mode 100644 .build/just/utilities.just create mode 100644 .build/just/version.just diff --git a/.build/just/bump-version.ts b/.build/just/bump-version.ts new file mode 100644 index 0000000..8cb38ff --- /dev/null +++ b/.build/just/bump-version.ts @@ -0,0 +1,62 @@ +// Bumps one part of the semantic version in package.json, for `just bump `. +// +// The parts after the one bumped are reset to 0, and a pre-release or build suffix is dropped: +// +// 2.0.1 major -> 3.0.0 minor -> 2.1.0 patch -> 2.0.2 +// 2.1.0-rc.1 patch -> 2.1.1 +// +// Only the "version" value is rewritten, in place, so the file keeps its own indentation, key order +// and line endings - re-serialising the JSON would reformat it. +// +// bun bump-version.ts [package.json] [--dry-run] + +import { readFileSync, writeFileSync } from "node:fs"; + +const parts = ["major", "minor", "patch"] as const; +type Part = (typeof parts)[number]; + +const args = process.argv.slice(2); +const dryRun = args.includes("--dry-run"); +const [part, file = "package.json"] = args.filter((arg) => arg !== "--dry-run"); + +if (!parts.includes(part as Part)) { + console.error(`Expected one of ${parts.join(", ")}, not '${part ?? ""}'.`); + process.exit(1); +} + +const text = readFileSync(file, "utf8"); +const versionPattern = /("version"\s*:\s*")([^"]*)(")/; +const match = versionPattern.exec(text); +if (!match) { + console.error(`No "version" field in ${file}.`); + process.exit(1); +} + +const current = match[2]; +const semver = /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(current); +if (!semver) { + console.error(`'${current}' in ${file} is not a major.minor.patch version.`); + process.exit(1); +} + +let [major, minor, patch] = semver.slice(1, 4).map(Number); +switch (part as Part) { + case "major": + [major, minor, patch] = [major + 1, 0, 0]; + break; + case "minor": + [minor, patch] = [minor + 1, 0]; + break; + case "patch": + patch += 1; + break; +} + +const next = `${major}.${minor}.${patch}`; +if (dryRun) { + console.log(` ${file}: ${current} -> ${next} (dry run, nothing written)`); + process.exit(0); +} + +writeFileSync(file, text.replace(versionPattern, `$1${next}$3`)); +console.log(` ${file}: ${current} -> ${next}`); diff --git a/.build/just/dotnet.just b/.build/just/dotnet.just new file mode 100644 index 0000000..9507263 --- /dev/null +++ b/.build/just/dotnet.just @@ -0,0 +1,53 @@ +# .NET recipes: tools, restore, build, clean, test and pack, all against one solution. +# +# Override these in the root Justfile. `solution_file` is the one nearly every repository sets; "." +# lets dotnet find the single solution or project in the repository root. + +solution_file := "." +build_configuration := "Debug" +artifacts_folder := "./artifacts" + +# Every test. A TUnit/MTP tree-node filter: /assembly/namespace/class/test. +test_filter := "/*/*/*/*/" + +# Restore the repository's .NET local tools (.config/dotnet-tools.json) +[group('Build and Test')] +ensure-tools: + dotnet tool restore + +# Restore NuGet packages for the solution +[group('Build and Test')] +restore *args: + echo "==> Restoring {{ BLUE }}{{ solution_file }}{{ NORMAL }}" + dotnet restore "{{ solution_file }}" {{ args }} + +# Build the solution with build_configuration (default: Debug) +[group('Build and Test')] +build *args: + echo "==> Building {{ BLUE }}{{ solution_file }}{{ NORMAL }} ({{ GREEN }}{{ current_version }}{{ NORMAL }}) with configuration {{ YELLOW }}{{ build_configuration }}{{ NORMAL }}" + dotnet build "{{ solution_file }}" --configuration "{{ build_configuration }}" {{ args }} + +# Clean the solution with build_configuration (default: Debug) +[group('Build and Test')] +clean *args: + echo "==> Cleaning {{ BLUE }}{{ solution_file }}{{ NORMAL }} with configuration {{ YELLOW }}{{ build_configuration }}{{ NORMAL }}" + dotnet clean "{{ solution_file }}" --configuration "{{ build_configuration }}" {{ args }} + +# Run the tests matching a tree-node filter (default: every test) +# +# just test "/*/*/*/*[Category=Unit]" +# just test "/*/*/ProjectHarnessTests/*" +# +# Exit code 8 - "no test ran" - is ignored, so a filter that matches nothing in one test project does +# not fail the run for the others. +[doc('Run the tests matching a tree-node filter (default: every test)')] +[group('Build and Test')] +test filter=test_filter *args: + echo "==> Testing {{ BLUE }}{{ solution_file }}{{ NORMAL }} ({{ YELLOW }}{{ build_configuration }}{{ NORMAL }}) with filter {{ GREEN }}{{ filter }}{{ NORMAL }}" + dotnet test --project "{{ solution_file }}" --configuration "{{ build_configuration }}" --treenode-filter "{{ filter }}" --ignore-exit-code 8 {{ args }} + +# Pack every packable project into artifacts_folder (default: ./artifacts) +[group('Build and Test')] +pack artifact_folder=artifacts_folder *args: + echo "==> Packing {{ BLUE }}{{ solution_file }}{{ NORMAL }} ({{ GREEN }}{{ current_version }}{{ NORMAL }}) to {{ YELLOW }}{{ artifact_folder }}{{ NORMAL }}" + dotnet pack "{{ solution_file }}" --configuration "{{ build_configuration }}" --output "{{ artifact_folder }}" {{ args }} diff --git a/.build/just/env.just b/.build/just/env.just new file mode 100644 index 0000000..6156f34 --- /dev/null +++ b/.build/just/env.just @@ -0,0 +1,56 @@ +# The environment every recipe runs in: telemetry opt-outs, and the .NET CLI speed-ups. +# +# `export` hands each value to every process a recipe starts - dotnet, bun, pwsh, git. Each one is a +# default: `env(NAME, value)` keeps whatever the caller's environment already says, so a developer +# who has opted back in, or a CI job that sets its own value, is never overridden. + +# -- Telemetry and tracking -------------------------------------------------------------------------- + +# The .NET CLI, MSBuild and Aspire. +export DOTNET_CLI_TELEMETRY_OPTOUT := env("DOTNET_CLI_TELEMETRY_OPTOUT", "1") +export MSBUILD_TELEMETRY_OPTOUT := env("MSBUILD_TELEMETRY_OPTOUT", "1") +export ASPIRE_CLI_TELEMETRY_OPTOUT := env("ASPIRE_CLI_TELEMETRY_OPTOUT", "true") +export ASPIRE_DASHBOARD_TELEMETRY_OPTOUT := env("ASPIRE_DASHBOARD_TELEMETRY_OPTOUT", "true") + +# The Azure SDKs and the Azure MCP server. +export AZURE_CORE_COLLECT_TELEMETRY := env("AZURE_CORE_COLLECT_TELEMETRY", "0") +export AZURE_MCP_COLLECT_TELEMETRY := env("AZURE_MCP_COLLECT_TELEMETRY", "0") + +# PowerShell, for scripts a recipe runs through pwsh, and Git Credential Manager. +export POWERSHELL_TELEMETRY_OPTOUT := env("POWERSHELL_TELEMETRY_OPTOUT", "1") +export GCM_TELEMETRY_OPTOUT := env("GCM_TELEMETRY_OPTOUT", "1") + +# JavaScript tooling: Next.js, Astro, Yarn, and the funding banners printed by postinstall scripts. +export NEXT_TELEMETRY_DISABLED := env("NEXT_TELEMETRY_DISABLED", "1") +export ASTRO_TELEMETRY_DISABLED := env("ASTRO_TELEMETRY_DISABLED", "1") +export YARN_ENABLE_TELEMETRY := env("YARN_ENABLE_TELEMETRY", "0") +export DISABLE_OPENCOLLECTIVE := env("DISABLE_OPENCOLLECTIVE", "true") + +# Claude Code, when a recipe launches it. +export CLAUDE_CLI_TELEMETRY_OPTOUT := env("CLAUDE_CLI_TELEMETRY_OPTOUT", "1") +export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC := env("CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC", "1") +export DISABLE_ERROR_REPORTING := env("DISABLE_ERROR_REPORTING", "1") +export DISABLE_TELEMETRY := env("DISABLE_TELEMETRY", "1") + +# The cross-tool conventions, honoured by Bun and many other CLIs. +export DO_NOT_TRACK := env("DO_NOT_TRACK", "1") +export TELEMETRY_DISABLED := env("TELEMETRY_DISABLED", "1") + +# -- .NET CLI speed and noise ------------------------------------------------------------------------ + +# No welcome banner or first-run notice. +export DOTNET_NOLOGO := env("DOTNET_NOLOGO", "1") + +# The NativeAOT CLI host (.NET 11): near-instant `dotnet --version`, `--help` and tool launches, with +# everything else falling back to the managed CLI. On by default; opt out with DOTNET_CLI_ENABLEAOT=false. +export DOTNET_CLI_ENABLEAOT := env("DOTNET_CLI_ENABLEAOT", "true") + +# The MSBuild server (DOTNET_CLI_USE_MSBUILD_SERVER) is deliberately left to the SDK's own default. +# Forcing it on makes every `dotnet build` share one long-lived MSBuild process, and its NuGet SDK +# resolver keeps the settings it first read: a build under a different nuget.config - a test +# harness's throwaway consumer, a second repository - then resolves SDKs with the wrong sources and +# fallback folders, and fails with MSB4242. Set it yourself where every build shares one NuGet +# configuration; `just scrub` shuts the server down. + +# Multithreaded MSBuild (-mt) is deliberately not set here. Purview.BuildSdk bootstraps it into the +# repository's Directory.Build.rsp, so a plain `dotnet build` and an IDE build get it as well. diff --git a/.build/just/index.just b/.build/just/index.just new file mode 100644 index 0000000..1d73bbe --- /dev/null +++ b/.build/just/index.just @@ -0,0 +1,41 @@ +# The barrel for the shared just modules. The root Justfile imports this file, and nothing else: +# +# set allow-duplicate-variables +# set allow-duplicate-recipes +# +# import ".build/just/index.just" +# +# Every module gives its variables a default. The root Justfile overrides one by defining the same +# name - `solution_file := "src/Acme.slnx"` - and overrides a no-op hook such as `_after-bump` the +# same way. Both settings are what let a root definition win; without them a duplicate is an error. +# +# The required modules are imported unconditionally. The optional ones use `import?`, so a module is +# switched on by copying its file into this folder and off by deleting it: this file never changes. +# +# These files are copied verbatim from the purview-buildsdk-justfile skill. Change a recipe there, +# not here, and put anything specific to one repository in its root Justfile. + +# Telemetry opt-outs and the .NET CLI speed-ups, exported to every recipe. +import "env.just" + +# version, bump +import "version.just" + +# ensure-tools, restore, build, clean, test, pack +import "dotnet.just" + +# lint-check, lint-fix, vs, scrub +import "utilities.just" + +# pipeline-pr, pipeline-build, pipeline-tests - local runs of the Purview.Build pipeline +import "purview-build.just" + +# skills-* - the Purview.BuildSdk agent-skill targets +import "skills.just" + +# Optional. pipeline-pack-validate, pipeline-local-release, pipeline-release - for a repository that +# packs NuGet packages. +import? "purview-build-nuget.just" + +# Optional. docs, docs-install, docs-check - for a pm-docs-site project site (purview-dev/pm-skills). +import? "docs.just" diff --git a/.build/just/purview-build-nuget.just b/.build/just/purview-build-nuget.just new file mode 100644 index 0000000..2154876 --- /dev/null +++ b/.build/just/purview-build-nuget.just @@ -0,0 +1,30 @@ +# Optional: Purview.Build pipeline runs that pack, validate and publish NuGet packages. Copy this file +# into the module folder only when the repository packs packages; the barrel imports it if present. +# +# Pack validation reads PackValidation in .config/purview-build.json. Its RequiredContent lists every +# file each package must contain, and a packed file it does not list fails the run - so a new file +# under a package's Sdk/, build/ or buildTransitive/ needs a RequiredContent entry too. + +# Run the pipeline through pack and pack validation (restore, build, lint, tests, pack, validate), publishing nothing +[group('Pipeline')] +pipeline-pack-validate *args: ensure-tools + echo "==> Running the pack and validate pipeline" + {{ pipeline_tool }} --Build:RunPack=true --Build:ValidatePack=true --Release:Mode=None {{ args }} + +# Run the release pipeline, publishing to a local NuGet feed (restore, build, lint, tests, pack, validate, publish) +# +# `just` runs recipes through sh, which strips backslashes from unquoted arguments. Set the +# LOCAL_NUGET_FEED_PATH environment variable, or use forward slashes: +# +# just pipeline-local-release --PublishLocalNuGet:LocalFeedPath=p:/_sync-projects/.local-nuget/ +[doc('Run the release pipeline, publishing to a local NuGet feed (restore, build, lint, tests, pack, validate, publish)')] +[group('Pipeline')] +pipeline-local-release *args: ensure-tools + echo "==> Running the local release pipeline" + {{ pipeline_tool }} --Release:Mode=LocalNuGet {{ args }} + +# Run the release pipeline, publishing to NuGet (restore, build, lint, tests, pack, validate, publish, GitHub release) +[group('Pipeline')] +pipeline-release *args: ensure-tools + echo "==> Running the release pipeline" + {{ pipeline_tool }} --Release:Mode=NuGet {{ args }} diff --git a/.build/just/purview-build.just b/.build/just/purview-build.just new file mode 100644 index 0000000..244e44c --- /dev/null +++ b/.build/just/purview-build.just @@ -0,0 +1,24 @@ +# Local runs of the Purview.Build pipeline - the same `dotnet purview-build` tool, and the same +# .config/purview-build.json, that CI runs. Every Build stage - tests, lint, pack and pack validation - +# runs unless that file or an argument turns it off. Anything after the recipe name is passed to the +# tool, so a setting can be overridden for one run: `just pipeline-pr --Build:TestFilter="/*/*/*/*[Category=Unit]"`. + +pipeline_tool := "dotnet purview-build" + +# Run the PR pipeline (restore, build, lint, tests, pack, validate), as configured +[group('Pipeline')] +pipeline-pr *args: ensure-tools + echo "==> Running the PR pipeline" + {{ pipeline_tool }} {{ args }} + +# Run the build pipeline (restore, build, lint, pack, validate), without tests +[group('Pipeline')] +pipeline-build *args: ensure-tools + echo "==> Running the build pipeline" + {{ pipeline_tool }} --Build:RunTests=false --Release:Mode=None {{ args }} + +# Run the pipeline with tests forced on and release off (restore, build, lint, tests, pack, validate) +[group('Pipeline')] +pipeline-tests *args: ensure-tools + echo "==> Running the tests pipeline" + {{ pipeline_tool }} --Build:RunTests=true --Release:Mode=None {{ args }} diff --git a/.build/just/skills.just b/.build/just/skills.just new file mode 100644 index 0000000..0d33902 --- /dev/null +++ b/.build/just/skills.just @@ -0,0 +1,52 @@ +# The Purview.BuildSdk agent-skill targets. Each recipe names one target; the behaviour lives there. +# +# The targets are a thin wrapper over the standard skills CLI (`bun x skills` by default), run from the +# repository root. Every skill target runs once for the whole solution, however many projects it holds, +# so the recipes name the solution, not a hand-picked project. +# +# Every recipe here is run by a person, on purpose. Never make one a dependency of build, test or +# default, or call skills-add, -install, -update or -fix from a git hook: they change the repository, +# and the SDK refuses to run them inside a build (PRSKL0009). skills-check is read-only. +# +# The runner and agents are MSBuild properties (PurviewSkillsRunner, PurviewSkillsAgents), set once in +# Directory.Build.props. Pass a one-off through *args; `dotnet msbuild -p:` splits on `,` and `;`, so +# escape the separator: `just skills-update -p:PurviewSkillsAgents=claude-code%2Ccodex`. + +skills_project := solution_file + +# Install skills from another repository through the skills CLI (append '#' to pin it) +# +# just skills-add purview-dev/engineering-playbook +[doc("Install skills from another repository through the skills CLI (append '#' to pin it)")] +[group('Agent Skills')] +skills-add source *args: + echo "==> Installing skills from {{ BLUE }}{{ source }}{{ NORMAL }}" + dotnet msbuild "{{ skills_project }}" -t:InstallPurviewSkills -p:PurviewSkillsSource={{ source }} -v:n {{ args }} + +# Restore every skill skills-lock.json records - how a fresh clone gets the repository's skills back +[group('Agent Skills')] +skills-install *args: + dotnet msbuild "{{ skills_project }}" -t:InstallPurviewSkills -v:n {{ args }} + +# Update the agent skills by re-adding every unique source in skills-lock.json +# +# Each source is re-added at its latest with every skill it has, which refreshes the installed skills +# and adds any a source has gained; `skills update` is never run. FixPurviewSkills then removes links +# from agent directories PurviewSkillsAgents does not select, and does nothing when it is unset. +# The -t: value is quoted because sh would otherwise end the command at the `;`. +# +# just skills-update -p:PurviewSkillsDryRun=true +[doc('Update the agent skills by re-adding every unique source in skills-lock.json')] +[group('Agent Skills')] +skills-update *args: + dotnet msbuild "{{ skills_project }}" "-t:UpdatePurviewSkills;FixPurviewSkills" -v:n {{ args }} + +# Check that only the skill directories of the agents in PurviewSkillsAgents exist +[group('Agent Skills')] +skills-check *args: + dotnet msbuild "{{ skills_project }}" -t:CheckPurviewSkills -v:n {{ args }} + +# Remove the skills CLI's links from agent directories PurviewSkillsAgents does not select +[group('Agent Skills')] +skills-fix *args: + dotnet msbuild "{{ skills_project }}" -t:FixPurviewSkills -v:n {{ args }} diff --git a/.build/just/utilities.just b/.build/just/utilities.just new file mode 100644 index 0000000..d813497 --- /dev/null +++ b/.build/just/utilities.just @@ -0,0 +1,44 @@ +# Formatting, opening the solution, and scrubbing the build output. + +csharpier := "dotnet csharpier" + +# Check formatting with CSharpier +[group('Utilities')] +lint-check: + {{ csharpier }} check . + +# Format the code with CSharpier +[group('Utilities')] +lint-fix: + {{ csharpier }} format . + +# Open the solution in Visual Studio, or whichever application is registered for it +[group('Utilities')] +[windows] +vs: + start "" "{{ solution_file }}" + +# Open the solution in whichever application is registered for it +[group('Utilities')] +[macos] +vs: + open "{{ solution_file }}" + +# Open the solution in whichever application is registered for it +[group('Utilities')] +[linux] +vs: + xdg-open "{{ solution_file }}" + +# Delete every bin/, obj/ and artifacts_folder, stop the build servers, and restore from scratch +# +# The build servers go first: the MSBuild server and the compiler server hold files open under obj/, +# which on Windows stops them being deleted. node_modules/ and .git/ are never searched. +[doc('Delete every bin/, obj/ and artifacts_folder, stop the build servers, and restore from scratch')] +[group('Utilities')] +scrub: + echo "==> Scrubbing build output and stopping the build servers" + dotnet build-server shutdown + find . \( -name node_modules -o -name .git \) -prune -o -type d \( -name bin -o -name obj \) -prune -exec rm -rf {} + + rm -rf "{{ artifacts_folder }}" + just restore --force-evaluate diff --git a/.build/just/version.just b/.build/just/version.just new file mode 100644 index 0000000..09dbb37 --- /dev/null +++ b/.build/just/version.just @@ -0,0 +1,28 @@ +# The package version, from package.json: the single source of truth Purview.BuildSdk versions every +# project and package from. + +version_file := "package.json" + +# Read by just itself rather than by spawning bun, so `just --list` needs no Node tooling. +current_version := if path_exists(version_file) == "true" { replace_regex(read(version_file), '(?s).*?"version"\s*:\s*"([^"]*)".*', '$1') } else { "0.0.0" } + +# Display the current version, from package.json +[group('Version')] +version: + echo "==> Current version: {{ GREEN }}{{ current_version }}{{ NORMAL }} (from {{ version_file }}, stamped into every build by Purview.BuildSdk)" + +# Bump one part of the version in package.json - major, minor or patch - resetting the parts after it +# +# just bump minor # 2.0.1 -> 2.1.0 +# just bump patch --dry-run # print the new version, write nothing +# +# A pre-release suffix is dropped. Requires Bun. Afterwards it runs `_after-bump`, which does nothing +# unless the root Justfile overrides it to refresh whatever else pins the version. +[doc('Bump one part of the version in package.json - major, minor or patch - resetting the parts after it')] +[arg("part", pattern="major|minor|patch")] +[group('Version')] +bump part *args: && _after-bump + bun "{{ source_directory() / 'bump-version.ts' }}" "{{ part }}" "{{ version_file }}" {{ args }} + +# Runs after a successful `bump`. Override it in the root Justfile, e.g. `_after-bump: version-sync`. +_after-bump: diff --git a/AGENTS.md b/AGENTS.md index 9d3a202..a283b78 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -72,17 +72,21 @@ Before changing build/SDK configuration or adding/moving projects, consult the S ## Commands -Build and test (see also the `Justfile`): +Build and test. The root `Justfile` holds only this repository's variables and recipes; the shared +recipes — `build`, `test`, `pack`, `restore`, `lint-check`/`lint-fix`, `vs`, `scrub`, `version`, +`bump`, the pipeline runs and the `skills-*` targets — are modules under `.build/just/`, copied +verbatim from the `purview-buildsdk-justfile` skill. Change a shared recipe there, not in the copy: ```bash just build # dotnet build src/ZodSharp.slnx -c Debug -just test # dotnet test src/ZodSharp.slnx -c Debug --treenode-filter "/*/*/*/*" +just test # dotnet test --project src/ZodSharp.slnx -c Debug --treenode-filter "/*/*/*/*" just lint-check # dotnet csharpier check . just lint-fix # dotnet csharpier format . just pack # dotnet pack src/ZodSharp.slnx -c Debug -o artifacts just perf-tests # dotnet run --project src/src/Benchmarks/Benchmarks.csproj -c Debug just pipeline-pr # PR pipeline via Purview.Build (restore, build, lint, tests) just pipeline-release # Release pipeline (pack, publish, GitHub release) +just bump patch # bump package.json's version (major|minor|patch); --dry-run prints only ``` TypeScript-side tooling uses Bun: @@ -254,7 +258,10 @@ hand - the CLI is its only writer, and a hand edit no longer matches the lockfile's hash. This repository's *own* skills are never installed here; they live in `skills/` (below), and a second copy would drift. `Purview.BuildSdk`'s `InstallPurviewSkills` target delegates to the same CLI; `src/Directory.Build.props` sets `PurviewSkillsAgents=universal` so -it is restricted the same way rather than defaulting to every agent (`*`). +it is restricted the same way rather than defaulting to every agent (`*`). The `skills-add`, +`skills-install`, `skills-update`, `skills-check` and `skills-fix` recipes in `.build/just/skills.just` +run those targets; every one but `skills-check` changes the repository, so they are run by hand and +never as a dependency of a build, test or hook. `src/tests/Repository.UnitTests/InstalledSkillTests.cs` keeps this honest: nothing under `.agents/skills/` is tracked, the `.agents/skills/` and `.claude/` ignore rules are in place, every diff --git a/Justfile b/Justfile index 82be2a0..46abe42 100644 --- a/Justfile +++ b/Justfile @@ -1,58 +1,54 @@ +# Recipes for Purview.ZodSharp. Run `just` for the list. +# +# The shared recipes come from .build/just/, copied verbatim from the purview-buildsdk-justfile +# skill. Change them there, not here; this file holds what belongs to this repository. + set quiet +# Let a definition here override a module's default variable or no-op hook. +set allow-duplicate-variables +set allow-duplicate-recipes + +import ".build/just/index.just" + +# The one solution. Purview.Build names the same path in .config/purview-build.json. +solution_file := "src/ZodSharp.slnx" + +# Every test, matching TestFilter in .config/purview-build.json so a local run selects what CI does. +test_filter := "/*/*/*/*" + +# The skills targets are invoked on a project, not the solution: Benchmarks deliberately opts out of +# Purview.BuildSdk (it shadows Directory.Build.props for BenchmarkDotNet's generated project), so +# MSBuild finds no skill target in it and a solution-wide run fails with MSB4057. Any project that +# imports the SDK carries the targets, and the work is repository-wide either way. +skills_project := "src/src/ZodSharp/ZodSharp.csproj" + root_folder := "src" -solution := root_folder / "ZodSharp.slnx" perf_tests_project := root_folder / "src" / "Benchmarks" / "Benchmarks.csproj" aot_sample_project := root_folder / "src" / "Examples.MinimalApi" / "Examples.MinimalApi.csproj" trim_verification_project := root_folder / "tests" / "TrimSafety.Verification" / "TrimSafety.Verification.csproj" wasm_client_project := root_folder / "src" / "Examples.Blazor.Client" / "Examples.Blazor.Client.csproj" # Native AOT cannot cross-compile between operating systems, so the sample publishes for this machine by default. default_rid := (if os_family() == "windows" { "win" } else if os() == "macos" { "osx" } else { "linux" }) + "-" + (if arch() == "aarch64" { "arm64" } else { "x64" }) -build_configuration := "Debug" -artifacts_folder := "./artifacts" -default_test_filter := "/*/*/*/*" - -csharpier := "dotnet csharpier" -pipeline_tool := "dotnet purview-build" [private] default: just --list -# Restore the repository's .NET local tools (.config/dotnet-tools.json) -[private] -ensure-pipeline-tool: - dotnet tool restore - -# Run the PR pipeline (restore, build, lint, tests) -[group('Pipeline')] -pipeline-pr *args: ensure-pipeline-tool - echo "Running PR pipeline..." - {{ pipeline_tool }} {{ args }} - -# Run the build pipeline (restore, build, lint) -[group('Pipeline')] -pipeline-build *args: ensure-pipeline-tool - echo "Running build pipeline..." - {{ pipeline_tool }} --Build:RunTests=false --Release:Mode=None {{ args }} - -# Run the release pipeline (restore, build, lint, tests, pack, publish, GitHub release) -[group('Pipeline')] -pipeline-release *args: ensure-pipeline-tool - echo "Running release pipeline..." - {{ pipeline_tool }} --Release:Mode=NuGet {{ args }} - -# Run the pipeline through pack + validate (restore, build, lint, tests, pack, validate pack contents) without publishing/releasing +# Local: this repository formats the tree first, so a local release cannot fail its own lint stage on +# unformatted code. Everything else is the shared recipe's behaviour, and the arguments pass through. +[doc('Run the release pipeline, publishing to a local NuGet feed (restore, build, lint, tests, pack, validate, publish)')] [group('Pipeline')] -pipeline-pack-validate *args: ensure-pipeline-tool - echo "Running pack + validate pipeline..." - {{ pipeline_tool }} --Build:RunPack=true --Build:ValidatePack=true --Release:Mode=None {{ args }} +pipeline-local-release *args: ensure-tools lint-fix + echo "==> Running the local release pipeline" + {{ pipeline_tool }} --Release:Mode=LocalNuGet {{ args }} # Build and run a throwaway consumer against the packed generator. # # The in-repo generator tests run against the unmerged generator, and pack validation only checks the # IL-merged assembly is present in the .nupkg - not that it loads and generates. That merge has regressed # twice (#36, #38), both times silently breaking consumers while this repository's tests stayed green. +[doc('Build and run a throwaway consumer against the packed generator')] [group('Pipeline')] smoke-packed-generator *args: echo "Running the packed generator smoke test..." @@ -66,6 +62,7 @@ smoke-packed-generator *args: # Every other publish gate builds against ProjectReferences; this is the one that proves what ships. The CI # `packed-consumers` job runs it for linux-x64. Purview.SourceGeneratorFramework is restored from nuget.org, plus # ZODSHARP_SGF_FEED or LOCAL_NUGET_FEED_PATH when set (or pass -SourceGeneratorFrameworkFeed). +[doc('Pack every package to an isolated feed, then publish throwaway consumers that reference the packages only')] [group('Pipeline')] smoke-packed-consumers *args: echo "Running the packed consumer gate..." @@ -75,8 +72,9 @@ smoke-packed-consumers *args: # file into scratch copies of the packed packages and runs the real purview-build validation on them. Reads artifacts/, # so pack first (`just pipeline-pack-validate`, or `just pack ./artifacts -c Release`). `just pipeline-local-release` # moves its packages to the local feed, so pass -PackagesFolder p:/_sync-projects/.local-nuget after it. +[doc('Prove every PackValidation ForbiddenContent rule in .config/purview-build.json rejects a package')] [group('Pipeline')] -verify-pack-rules *args: ensure-pipeline-tool +verify-pack-rules *args: ensure-tools echo "Proving the pack-validation forbidden-content rules..." pwsh -NoProfile -File scripts/test-pack-validation-rules.ps1 {{ args }} @@ -85,34 +83,6 @@ verify-pack-rules *args: ensure-pipeline-tool scan-compiler-host-leaks +paths: pwsh -NoProfile -File scripts/assert-no-compiler-host-assemblies.ps1 -Path {{ paths }} -# Run the release pipeline (restore, build, lint, tests, pack, local nuget publish) -# Note: `just` runs recipes through the shell, which strips backslashes from unquoted arguments. -# Use the LOCAL_NUGET_FEED_PATH environment variable or forward slashes, e.g. -# just pipeline-local-release --PublishLocalNuGet:LocalFeedPath=p:/_sync-projects/.local-nuget/ -[group('Pipeline')] -pipeline-local-release *args: ensure-pipeline-tool lint-fix - echo "Running local release pipeline..." - {{ pipeline_tool }} --Release:Mode=LocalNuGet {{ args }} - -# Run the pipeline with tests enabled -[group('Pipeline')] -pipeline-tests *args: - just ensure-pipeline-tool - echo "Running tests pipeline..." - {{ pipeline_tool }} --Build:RunTests=true --Release:Mode=None {{ args }} - -# Build and test with the specified configuration, defaulting to "Debug" -[group('Build and Test')] -build *args: - echo "Building {{ BLUE }}{{ solution }}{{ NORMAL }} with configuration {{ YELLOW }}{{ build_configuration }}{{ NORMAL }}" - dotnet build {{ solution }} -c {{ build_configuration }} {{ args }} - -# Clean the solution with the specified configuration, defaulting to "Debug" -[group('Build and Test')] -clean *args: - echo "Cleaning {{ BLUE }}{{ solution }}{{ NORMAL }} with configuration {{ YELLOW }}{{ build_configuration }}{{ NORMAL }}" - dotnet clean {{ solution }} -c {{ build_configuration }} {{ args }} - # Run the performance benchmarks with the specified configuration, defaulting to "Debug" [group('Build and Test')] perf-tests *args: @@ -120,24 +90,6 @@ perf-tests *args: # Benchmarks multi-target net10.0/net11.0; default to net10.0. Pass `-f net11.0` to run on .NET 11. dotnet run --project {{ perf_tests_project }} -c Release -f net10.0 {{ args }} -# Run tests with the specified configuration, defaulting to "Debug" -[group('Build and Test')] -test filter=default_test_filter *args: - echo "Running tests for {{ BLUE }}{{ solution }}{{ NORMAL }} with configuration {{ YELLOW }}{{ build_configuration }}{{ NORMAL }} and filter {{ GREEN }}{{ filter }}{{ NORMAL }}" - dotnet test {{ solution }} -c {{ build_configuration }} --treenode-filter "{{ filter }}" {{ args }} - -# Restore dependencies for the solution -[group('Build and Test')] -restore *args: - echo "Restoring dependencies for {{ BLUE }}{{ solution }}{{ NORMAL }}" - dotnet restore {{ solution }} {{ args }} - -# Create NuGet package for the project -[group('Build and Test')] -pack publish_folder=artifacts_folder *args: - echo "Packing {{ BLUE }}{{ solution }}{{ NORMAL }} with configuration {{ YELLOW }}{{ build_configuration }}{{ NORMAL }} to {{ GREEN }}{{ publish_folder }}{{ NORMAL }}" - dotnet pack {{ solution }} -c {{ build_configuration }} -o {{ publish_folder }} {{ args }} - # The CI `aot-sample` job runs the same publish for linux-x64. Windows needs the MSVC C++ build tools, Linux clang. # Publish the Examples.MinimalApi sample with Native AOT, failing on any trim (IL2xxx) or AOT (IL3xxx) warning [group('Build and Test')] @@ -168,32 +120,3 @@ wasm-size *args: dotnet publish {{ wasm_client_project }} -c Release -o {{ artifacts_folder }}/wasm-trimmed -warnaserror {{ args }} pwsh -NoProfile -File scripts/check-wasm-size.ps1 -PublishDirectory {{ artifacts_folder }}/wasm-trimmed pwsh -NoProfile -File scripts/assert-no-compiler-host-assemblies.ps1 -Path {{ artifacts_folder }}/wasm-trimmed {{ root_folder }}/src/Examples.Blazor.Client/bin/Release - -# Displays the current version of the project. -# Requires Bun. -[group('Build and Test')] -version: - bun -e "console.log('Current Version: {{ GREEN }}' + require('./package.json').version + '{{ NORMAL }}')" - -# Check code formatting using CSharpier -[group('Utilities')] -lint-check: - {{ csharpier }} check . - -# Fix code formatting issues using CSharpier -[group('Utilities')] -lint-fix: - {{ csharpier }} format . - -# Open the solution in Visual Studio/ Registered application -[group('Utilities')] -vs: - open {{ solution }} - -# Clean up the repository by removing build artifacts, bin/obj folders etc, and shutting down the build server -[group('Utilities')] -scrub: - find . -type d \( -name bin -o -name obj \) -exec rm -rf {} + - just clean - just restore --force-evaluate - dotnet build-server shutdown From 78267dc422112c24c423cde0cf0b260bb3b6f03c Mon Sep 17 00:00:00 2001 From: Kieron Lanning Date: Mon, 16 Nov 2026 08:12:23 +0000 Subject: [PATCH 2/3] docs: pair the Blazor diagram with a LikeC4 model and label the fences --- README.md | 2 +- docs/wiki/development/Contributing.md | 9 ++-- docs/wiki/diagrams/blazor-projects.c4 | 51 +++++++++++++++++++++ docs/wiki/hosting/Blazor-Integration.md | 16 +++++-- docs/wiki/quality/Cross-Platform-Interop.md | 2 +- 5 files changed, 71 insertions(+), 9 deletions(-) create mode 100644 docs/wiki/diagrams/blazor-projects.c4 diff --git a/README.md b/README.md index 8140c02..24167b1 100644 --- a/README.md +++ b/README.md @@ -356,7 +356,7 @@ See the [performance README](src/src/Benchmarks/README.md) for detailed benchmar ## Architecture -``` +```text src/ ├── src/ │ ├── ZodSharp/ # Core validation library (Core, Schemas, Rules, JsonSchema, Unions) diff --git a/docs/wiki/development/Contributing.md b/docs/wiki/development/Contributing.md index d970921..2c96e50 100644 --- a/docs/wiki/development/Contributing.md +++ b/docs/wiki/development/Contributing.md @@ -4,7 +4,7 @@ Contributions are welcome. Please open an issue or pull request against [purview ## Repository layout -``` +```text src/ ZodSharp.slnx src/ @@ -70,7 +70,7 @@ This wiki lives in `docs/wiki/`, which is the documentation source for [purview. One folder per topic area, so a page can be found by what it is about rather than by remembering its file name: -``` +```text docs/wiki/ Getting-Started.md The landing page (docs.rootPage) Fluent-Schema-API.md Deep-linked by the site catalogue (docsPage) @@ -84,6 +84,7 @@ docs/wiki/ hosting/ Microsoft.Extensions.Validation, OpenAPI, Blazor, HttpClient, DI, localization quality/ Guarantees, performance, trimming/AOT, cross-platform interop development/ This page and the release flow + diagrams/ LikeC4 models the pages embed (never published as pages) ``` The pages are also grouped into seven sections, in reading order. The same seven sections, in the same order, are the groups in `_Sidebar.md`, the `## ` headings in `Home.md`, and the seven `Where to go next` bullets at the end of `Getting-Started.md` (the last of those name each section by the goal it serves rather than by its title). @@ -109,6 +110,8 @@ The pages are also grouped into seven sections, in reading order. The same seven - **Link to a sibling by file name, and to anything else by its path from the page**: `[Custom Rules](Custom-Rules.md)` within `schemas/`, `[Core Concepts](../concepts/Core-Concepts.md)` across folders, optionally with a fragment (`Core-Concepts.md#error-fields`). The sync resolves each link relative to the page it appears on. - **Renaming or moving a page changes its published URL.** Add the old slug to `docs.redirects` in the site's `zodsharp.yml` so bookmarks and inbound links keep working; the generated redirect never shadows a real page, so it activates when the move is released. - GitHub alert blockquotes (`> [!NOTE]`, `> [!TIP]`, `> [!WARNING]`, `> [!CAUTION]`, `> [!IMPORTANT]`) are converted to Starlight asides. +- **Every fence declares a language** (`csharp`, `json`, `bash`, `text`, ...): an unlabelled fence loses its syntax highlighting on GitHub and on the site. +- **Diagrams are never ASCII art.** Draw one as a LikeC4 model in `diagrams/`, paired with the Mermaid that GitHub renders, inside a `purview:likec4` block: an opening `` marker, one `mermaid` fence carrying the same nodes and edges, a `[LikeC4 model](../diagrams/.c4)` link, and the closing marker. purview.dev swaps the whole block for the model's interactive view and GitHub shows the Mermaid; a `.c4` file is never published as a page. Validate a model with `bunx likec4 validate docs/wiki/diagrams` before committing it. - Relative repository-path links (e.g. `src/src/ZodSharp/Z.cs`) are rewritten to GitHub blob URLs automatically. - Keep the `CrossPlatformUserSchema` (C#) and `UserSchema` (TypeScript) in sync when either changes. @@ -118,7 +121,7 @@ The pages are also grouped into seven sections, in reading order. The same seven 2. Add it to `_Sidebar.md` exactly once, inside that section's list and in the position a reader should meet it, with its path relative to the wiki root. 3. Add it to `Home.md` exactly once, in that section's table, with a one-line "what it answers". -`DocumentationWikiTests` (`src/tests/Repository.UnitTests`) enforces all three: every page is listed exactly once in the sidebar and is reachable from `Home.md`, every sidebar and page link resolves to an existing file, every sidebar section has a matching `## ` heading in `Home.md`, every folder holds at least one page listed in the sidebar, and every page opens with a single `# ` title. `just test` runs it. +`DocumentationWikiTests` (`src/tests/Repository.UnitTests`) enforces all three: every page is listed exactly once in the sidebar and is reachable from `Home.md`, every sidebar and page link resolves to an existing file, every sidebar section has a matching `## ` heading in `Home.md`, every folder that holds pages is one of the seven topic folders listed above (`diagrams/` holds only the LikeC4 models, which are not pages), and every page opens with a single `# ` title. `just test` runs it. ## Formatting diff --git a/docs/wiki/diagrams/blazor-projects.c4 b/docs/wiki/diagrams/blazor-projects.c4 new file mode 100644 index 0000000..88aa2db --- /dev/null +++ b/docs/wiki/diagrams/blazor-projects.c4 @@ -0,0 +1,51 @@ +// The three projects of a Blazor Web App and the ZodSharp packages each one references. +// +// Embedded by host!docs/wiki/hosting/Blazor-Integration.md through a purview:likec4 block, paired with +// a Mermaid fence so GitHub and purview.dev each render the diagram their renderer can show. One +// self-contained file per diagram: purview.dev compiles it on its own, so it carries its own +// specification, model and views and imports nothing. + +specification { + element project { + style { + shape rectangle + } + } + element package { + style { + shape rectangle + color secondary + } + } +} + +model { + server = project 'MyApp (server)' { + description 'Renders the components on the server and hosts the endpoints' + } + client = project 'MyApp.Client (WebAssembly)' { + description 'Runs the same components in the browser' + } + shared = project 'MyApp.Shared (models)' { + description 'The ZodSchema models, where the generator runs' + } + + blazor = package 'Purview.ZodSharp.Blazor' + aspnetcore = package 'Purview.ZodSharp.AspNetCore' + core = package 'Purview.ZodSharp' + + server -> blazor + server -> aspnetcore + client -> blazor + shared -> core + server -> shared 'references' + client -> shared 'references' +} + +views { + view blazorProjects { + title 'Blazor projects and the packages they reference' + include * + autoLayout LeftRight + } +} diff --git a/docs/wiki/hosting/Blazor-Integration.md b/docs/wiki/hosting/Blazor-Integration.md index 660c11e..32dc953 100644 --- a/docs/wiki/hosting/Blazor-Integration.md +++ b/docs/wiki/hosting/Blazor-Integration.md @@ -20,11 +20,19 @@ builder.Services.AddZodSharpBlazor(); A Blazor Web App typically looks like this: + +```mermaid +flowchart LR + server["MyApp (server)"] --> blazor[Purview.ZodSharp.Blazor] + server --> aspnetcore[Purview.ZodSharp.AspNetCore] + client["MyApp.Client (WebAssembly)"] --> blazor + shared["MyApp.Shared (models)"] --> core[Purview.ZodSharp] + server -- references --> shared + client -- references --> shared ``` -MyApp/ (server) -> Purview.ZodSharp.Blazor, Purview.ZodSharp.AspNetCore -MyApp.Client/ (WASM) -> Purview.ZodSharp.Blazor -MyApp.Shared/ (models) -> Purview.ZodSharp (the generator runs here) -``` + +[LikeC4 model](../diagrams/blazor-projects.c4) + `AddZodSharpBlazor(configureValidation, configure)` registers the Microsoft.Extensions.Validation bridge for **type validation only** (`AddZodSharpValidation(configureValidation, validateParameters: false)`), registers diff --git a/docs/wiki/quality/Cross-Platform-Interop.md b/docs/wiki/quality/Cross-Platform-Interop.md index 5e5bc5c..afd5b15 100644 --- a/docs/wiki/quality/Cross-Platform-Interop.md +++ b/docs/wiki/quality/Cross-Platform-Interop.md @@ -92,7 +92,7 @@ See [JSON Schema Export](../serialization/JsonSchema-Export.md) and [JSON Schema ## Directory layout -``` +```text src/ts/ TypeScript (Zod) schemas + fixture generation src/ts/fixtures/ generated JSON fixtures + manifest.json tests/ts/ vitest cross-platform tests From 6fc3f4515f5df08dfcd510150c73b0607266f25f Mon Sep 17 00:00:00 2001 From: Kieron Lanning Date: Mon, 16 Nov 2026 08:21:01 +0000 Subject: [PATCH 3/3] chore: refresh skills-lock.json after restoring the install --- skills-lock.json | 120 +++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 105 insertions(+), 15 deletions(-) diff --git a/skills-lock.json b/skills-lock.json index 0194adf..3432adb 100644 --- a/skills-lock.json +++ b/skills-lock.json @@ -1,6 +1,42 @@ { "version": 2, "skills": { + "add-catalogue-project": { + "source": "purview-dev/purview-dev.github.io", + "sourceType": "github", + "skillPath": "skills/add-catalogue-project/SKILL.md", + "computedHash": "fd7539da585809ea8e522c6d00fe8ebfead3a4dd0944c5c96a1ca0d7ce5639cd" + }, + "add-project-intake": { + "source": "purview-dev/purview-dev.github.io", + "sourceType": "github", + "skillPath": "skills/add-project-intake/SKILL.md", + "computedHash": "7bbdebc825ad435e35ebd350585dec218da32d44005b87b1949005e5356045ec" + }, + "audit-catalogue-projects": { + "source": "purview-dev/purview-dev.github.io", + "sourceType": "github", + "skillPath": "skills/audit-catalogue-projects/SKILL.md", + "computedHash": "9020e33be8d74bb6d4dac7012f1dc8d8c61fe0df903083eb3bb6dcff8192e67a" + }, + "docs-aggregation-rules": { + "source": "purview-dev/purview-dev.github.io", + "sourceType": "github", + "skillPath": "skills/docs-aggregation-rules/SKILL.md", + "computedHash": "01623aa4a66cd0109980b2ea335d259a5bb742530702dfbdce100e5a6d2eba59" + }, + "github-repo-metadata": { + "source": "purview-dev/purview-dev.github.io", + "sourceType": "github", + "skillPath": "skills/github-repo-metadata/SKILL.md", + "computedHash": "94429f2e0a07fbccbb2af8316759768ce86759ea9557e9118ae3a686f04a3c23" + }, + "project-manifest-reference": { + "source": "purview-dev/purview-dev.github.io", + "sourceType": "github", + "skillPath": "skills/project-manifest-reference/SKILL.md", + "computedHash": "dfbde8cf9eb8824bfddce91180eb2471c6c44c6a9946acec8408e40a830ca3d3" + }, "purview-architecture": { "source": "purview-dev/engineering-playbook", "sourceType": "github", @@ -17,61 +53,85 @@ "source": "purview-dev/build-sdk", "sourceType": "github", "skillPath": "skills/purview-buildsdk-adoption/SKILL.md", - "computedHash": "5ddad1fe7d1dc65c1b352743e5cd616d4720a33228b06faa6259572cd4a8c265" + "computedHash": "ed38157d532c45582bc3f768ca6605c4cbc1339fbbb6a45e34a8badee06af06f" }, "purview-buildsdk-configuration": { "source": "purview-dev/build-sdk", "sourceType": "github", "skillPath": "skills/purview-buildsdk-configuration/SKILL.md", - "computedHash": "9b9593e093aaf07ec0a427e7874c1dd2cda35b9a13a6701d7ae10af5ebd985a9" + "computedHash": "7f33e4fee919a7e67033763f76f8e99e585ef128c937c6df58ebdae823949934" + }, + "purview-buildsdk-docs-sync": { + "source": "purview-dev/build-sdk", + "sourceType": "github", + "skillPath": "skills/purview-buildsdk-docs-sync/SKILL.md", + "computedHash": "e04a1043a1bf2f70bda95b5a5f544cfd093bd6e3ca159ef1c2425ba6e8129e41" + }, + "purview-buildsdk-justfile": { + "source": "purview-dev/build-sdk", + "sourceType": "github", + "skillPath": "skills/purview-buildsdk-justfile/SKILL.md", + "computedHash": "a3eba9ce21459f6db54ea0ecbf1aadfc01109e1446f9ad0142ae0f5ff217a65c" + }, + "purview-buildsdk-msbuild-properties": { + "source": "purview-dev/build-sdk", + "sourceType": "github", + "skillPath": "skills/purview-buildsdk-msbuild-properties/SKILL.md", + "computedHash": "76af7d5e1d12fd159acea43d3591bb6543b7ecb8375f3cfdc2f090f28729431f" }, "purview-buildsdk-project-detection": { "source": "purview-dev/build-sdk", "sourceType": "github", "skillPath": "skills/purview-buildsdk-project-detection/SKILL.md", - "computedHash": "9a3cf78ad4df9c335780bbbfbc9f66f7986b6293359aab19edaadb5c79f70be8" + "computedHash": "8b39fdeba80cad1cfd19d394209affc95d2dbc3e6a2e0358d14dc54ba6892ed7" }, "purview-buildsdk-project-layout": { "source": "purview-dev/build-sdk", "sourceType": "github", "skillPath": "skills/purview-buildsdk-project-layout/SKILL.md", - "computedHash": "d8b1fb6b95ae5e91f81734616f70a9f3d2d7547dc7406e4eda0f8d674ebf808b" + "computedHash": "e2df530972d850894ea3129f30041b5f0a16a067b6a6b037188f920e81d488bb" }, "purview-buildsdk-repository-review": { "source": "purview-dev/build-sdk", "sourceType": "github", "skillPath": "skills/purview-buildsdk-repository-review/SKILL.md", - "computedHash": "babfe657a1eef5be67dc1e4ec387e9e8215fb0263956c4c926465fa27b648604" + "computedHash": "08a5b7a34511959b72702ae8107c15ece77a27a7ef58c0b6b08e25a206f76c25" + }, + "purview-buildsdk-settings-docs-sync": { + "source": "purview-dev/build-sdk", + "sourceType": "github", + "skillPath": "skills/purview-buildsdk-settings-docs-sync/SKILL.md", + "computedHash": "a2a121d7b1fb97bf2e4c63ed58a20cc737f7d844a10cf30862c62bece930e3ff" }, "purview-buildsdk-skill-installation": { "source": "purview-dev/build-sdk", "sourceType": "github", "skillPath": "skills/purview-buildsdk-skill-installation/SKILL.md", - "computedHash": "8e1dc7c0f499eb742264d5cc293784758c5f0499f849671a0be3353f91f89491" + "computedHash": "5a8cffd36dc696ec86276ddd089e9f859d4571b7606b46c0b82a5c52d5935e16" }, "purview-buildsdk-skill-tests": { "source": "purview-dev/build-sdk", "sourceType": "github", "skillPath": "skills/purview-buildsdk-skill-tests/SKILL.md", - "computedHash": "27b3520ced5c5a8009cfb47149f0fc1826246275d3ec2991667e1543b011d657" + "computedHash": "bfa5798b756ab0fdc174fcba98184a516135f61f5b99453fc62b042a5c3551fa" }, - "purview-buildsdk-skills-justfile": { + "purview-buildsdk-skills-layout": { "source": "purview-dev/build-sdk", "sourceType": "github", - "skillPath": "skills/purview-buildsdk-skills-justfile/SKILL.md", - "computedHash": "a41f7bbd28333e7f2e40cadbbdd35a75b2f626d72e53901cbc79c7325ac2e50c" + "skillPath": "skills/purview-buildsdk-skills-layout/SKILL.md", + "computedHash": "1067c53b6011c601c6a4b702ba327c461372c4fa3f6b36af746c0d10171c717d" }, "purview-buildsdk-testing": { "source": "purview-dev/build-sdk", "sourceType": "github", "skillPath": "skills/purview-buildsdk-testing/SKILL.md", - "computedHash": "e7e00ede43f5ee8aa4517329e4fdbde00a5a01bd8e98ea42990c851060bcaf9e" + "computedHash": "5faaf12203c835f1af452137304feed6b99c5e94d7fb1e628ba0b304751914f9" }, "purview-component-compatibility": { "source": "purview-dev/engineering-playbook", "sourceType": "github", "skillPath": "skills/purview-component-compatibility/SKILL.md", - "computedHash": "070634caa90d032e2319d6799edbee973be0f9380008917474909328e74f143b" + "computedHash": "973337ad2a39704e92059f2a0c6abdfcb62a62d18c904b2d7707635944012bab" }, "purview-engineering-principles": { "source": "purview-dev/engineering-playbook", @@ -91,6 +151,24 @@ "skillPath": "skills/purview-persistence/SKILL.md", "computedHash": "28e92fa8bccc241ca864b6731148bd721f47699baf3a1a2ec07cce42ed650bae" }, + "purview-site-assessment": { + "source": "purview-dev/purview-dev.github.io", + "sourceType": "github", + "skillPath": "skills/purview-site-assessment/SKILL.md", + "computedHash": "6112f08130fda26f0ef5fafbb7084d20b758c1cd5edd70d7a689d7933c6b2afa" + }, + "purview-site-docs": { + "source": "purview-dev/purview-dev.github.io", + "sourceType": "github", + "skillPath": "skills/purview-site-docs/SKILL.md", + "computedHash": "b11f8d1d71e5c07b978dd8308a15896890a2384f3545075d582a935565fb1ca1" + }, + "purview-site-integration": { + "source": "purview-dev/purview-dev.github.io", + "sourceType": "github", + "skillPath": "skills/purview-site-integration/SKILL.md", + "computedHash": "56ed9760a93e60a2abae8d790eb6405b93950d9de010e22ce3d5cf9e10e25802" + }, "purview-sourcegenerator-attribute-data-models": { "source": "purview-dev/sourcegenerator-framework", "sourceType": "github", @@ -101,13 +179,13 @@ "source": "purview-dev/sourcegenerator-framework", "sourceType": "github", "skillPath": "skills/purview-sourcegenerator-codewriter/SKILL.md", - "computedHash": "5874c7773f395a5fea123f447bc500a687760f256eb5f7646022f9fbd22cd111" + "computedHash": "efc58013ff2122eb56981d482f8b66345977f235339473d5db63afca45bee198" }, "purview-sourcegenerator-diagnostics": { "source": "purview-dev/sourcegenerator-framework", "sourceType": "github", "skillPath": "skills/purview-sourcegenerator-diagnostics/SKILL.md", - "computedHash": "8e3571221c2a2225f3826b0c501cd28ea2a27e91defd121f45117c0e36a308fd" + "computedHash": "751a6feac6487bb70dba6ceb9b8bfb7201bae9e3733e1634df7dea443fe4f6a1" }, "purview-sourcegenerator-packaging": { "source": "purview-dev/sourcegenerator-framework", @@ -125,7 +203,7 @@ "source": "purview-dev/sourcegenerator-framework", "sourceType": "github", "skillPath": "skills/purview-sourcegenerator-testing/SKILL.md", - "computedHash": "ef37df157bd9a589d487e79cffdecc4160aee59ca9000aea55d7204af097e883" + "computedHash": "027d6eb1b63783635b9000acd72ec4c3d06e129fed742e7b71a79fe7535040ed" }, "purview-sourcegenerator-tunit-tests": { "source": "purview-dev/sourcegenerator-framework", @@ -144,6 +222,18 @@ "sourceType": "github", "skillPath": "skills/purview-testing-conventions/SKILL.md", "computedHash": "e053513db856852a23aad0e22625e1408fdd63377acb793e6d720fe37b9f7214" + }, + "site-validation-loop": { + "source": "purview-dev/purview-dev.github.io", + "sourceType": "github", + "skillPath": "skills/site-validation-loop/SKILL.md", + "computedHash": "fbeadc96c6cf59d54cd037b5084aa3d0fb1dd89542705dd1c3a8ca5704b5b5da" + }, + "use-case-authoring": { + "source": "purview-dev/purview-dev.github.io", + "sourceType": "github", + "skillPath": "skills/use-case-authoring/SKILL.md", + "computedHash": "80be02ac4684ebe7bfe28aefcc87bb2682eda96f9fb5140722e6f7df16d05567" } } }