@ggui-ai/protocol-conformance 0.13.0 → 0.14.0

package/README.md

@@ -51,13 +51,16 @@ One declared grading gap on the action loop: `action-ack` proves the append half
 
 The behavioral fixture catalog above asserts what an implementation _does_ over the wire. Some protocol obligations aren't transport-observable at all — they are deterministic _validation functions_: given an input, accept or reject it. SPEC §7.7.2's gadget obligations are exactly this. Modeling them as WebSocket fixtures would mean faking wire frames the protocol never emits; instead the kit ships **pure-function catalogs** — accept/reject cases graded against a caller-supplied function, with no host, render, or transport.
 
-Each catalog ships its cases as raw JSON so a non-TypeScript implementer can grade their own implementation, and each runner takes the implementation as a callback — the kit never hard-binds a concrete one. Five catalogs ship today:
+Each catalog ships its cases as raw JSON so a non-TypeScript implementer can grade their own implementation, and each runner takes the implementation as a callback — the kit never hard-binds a concrete one. Eight catalogs ship today:
 
 - **`@ggui-ai/protocol-conformance/schema-conformance`** — which `DataContract.clientCapabilities` payloads a conformant parser MUST accept / reject (the gadget wire shape).
 - **`@ggui-ai/protocol-conformance/registration-conformance`** — which `(contract, appGadgets, appPublicEnv)` triples the push-time gadget gate stack MUST accept / reject, and with which precise SPEC §7.9 reject code (`gadget_not_registered` / `gadget_package_mismatch` / `gadget_public_env_missing` / `duplicate_gadget_hook`).
 - **`@ggui-ai/protocol-conformance/resolution-conformance`** — which bundle + style URLs the server MUST compute for a gadget descriptor's transport fields (`bundleHost` precedence, default host, loopback `http` scheme).
 - **`@ggui-ai/protocol-conformance/binding-conformance`** — which MCP tool-binding set a manifest resolves to (a declared `mcpTools` list wins entirely; blueprints without it derive bare tool-name entries from contract tool names) and which artifacts the registry `tool=` / `server=` search filters MUST match (SPEC §7.7.4.1).
 - **`@ggui-ai/protocol-conformance/props-schema-conformance`** — the schema-precise render arbiter (SPEC §2.3.2): the enforced-props-schema builder (drift), its RFC 8785 sha256 hash, the grammar-safe profile verdict, and returned-schema AUTHORITY (sample validity under the case's own `propsSchema`, including the 2026-08-19 out-of-vocabulary enum incident pinned as a permanent sample).
+- **`@ggui-ai/protocol-conformance/host-helper-conformance`** — which render coordinates a HOST-HELPER library MUST extract from a `tools/call` result, and which malformed results it MUST decline rather than guess at.
+- **`@ggui-ai/protocol-conformance/refusal-envelope-conformance`** — the tool result a server MUST project for a PRE-GENERATION refusal (SPEC §7.1's refused arm): an in-result `isError` (never a throw), `content[0].text` leading with the code, `structuredContent` carrying `{outcome: 'refused', refusal}` and nothing else, no `_meta` — and no envelope at all for a registered code whose surfaces exclude the render gate.
+- **`@ggui-ai/protocol-conformance/registry-completeness`** — the structural obligations a deployment's closed refusal-code registry MUST satisfy: `surfaces` non-empty, `code === key`, every `after-fix` entry naming who acts (`fixBy`), and `retry` inside the closed four-value set. Grades DATA rather than a function — the caller passes their registry.
 
 ```ts
 import { runSchemaConformance } from "@ggui-ai/protocol-conformance/schema-conformance";
@@ -77,7 +80,7 @@ if (schema.failed.length + gate.failed.length + urls.failed.length > 0) {
 }
 ```
 
-The `schema-conformance` meta-test binds its catalog to the live `@ggui-ai/protocol` `clientCapabilitiesSpecSchema` — a drift-catch if the wire schema diverges from the §7.7.2 obligations the catalog freezes. The `registration-conformance`, `resolution-conformance`, and `binding-conformance` meta-tests verify catalog coherence against faithful in-test implementations (the kit stays vendor-neutral — it does not depend on a server implementation); grading the _shipping_ gate / resolver is an implementation-side test that drives the corresponding runner.
+The `schema-conformance` meta-test binds its catalog to the live `@ggui-ai/protocol` `clientCapabilitiesSpecSchema` — a drift-catch if the wire schema diverges from the §7.7.2 obligations the catalog freezes. The `registration-conformance`, `resolution-conformance`, and `binding-conformance` meta-tests verify catalog coherence against faithful in-test implementations (the kit stays vendor-neutral — it does not depend on a server implementation); grading the _shipping_ gate / resolver is an implementation-side test that drives the corresponding runner. The two ggui#786 catalogs split the same way, and for the same reason: `registry-completeness` binds the LIVE `@ggui-ai/protocol` `PRE_GENERATION_REFUSAL_CODES` (the obligation IS a protocol declaration, so the drift-catch belongs kit-side, like `schema-conformance`), while `refusal-envelope-conformance` grades a kit-local reference projector (the obligation is an implementation behaviour, like `resolution-conformance`). Two of that ruling's six registry checks read repo source — the no-auto-retry docstring rule and the grep for code literals minted outside the registry file — and are therefore NOT in the kit: it publishes only `dist`, so a source walk could never run for an adopter. They live in `@ggui-ai/protocol`'s own suite. That split is declared, not hidden.
 
 ## Resource-read conformance — the MCP binding
 
@@ -116,7 +119,7 @@ It deliberately does **not** grade: the order in which a substrate-less server a
 
 What is actually graded against shipping code today, and what is still awaiting a driver. This is an inventory, not a roadmap — a mechanism is listed as proven only if a test in the repo drives it against the real implementation on every push.
 
-Every test below is a plain `*.test.ts` inside a package's `src/`, so it runs in that package's ordinary vitest suite. The ggui repo's per-push CI runs `turbo run test` across all non-e2e packages, so **all eight rows below are gated on every push** — the kit needs no dedicated workflow, and adopters wiring it into their own CI need nothing more than their existing unit-test task.
+Every test below is a plain `*.test.ts` inside a package's `src/`, so it runs in that package's ordinary vitest suite. The ggui repo's per-push CI runs `turbo run test` across all non-e2e packages, so **all ten rows below are gated on every push** — the kit needs no dedicated workflow, and adopters wiring it into their own CI need nothing more than their existing unit-test task.
 
 | Obligation                                                              | Graded against                                                                             | Driver                                                                                               |
 | ----------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------- |
@@ -128,6 +131,8 @@ Every test below is a plain `*.test.ts` inside a package's `src/`, so it runs in
 | `resources/read` typed failures + mount invariant                       | the shipping `registerGguiRenderResourceTemplate` in `@ggui-ai/mcp-server`                 | `mcp-server/src/mcp-apps-outbound.resource-read.conformance.test.ts` — **12 pass / 0 skip / 0 fail** |
 | Tool-binding resolution — declared wins, contract derivation (§7.7.4.1) | the shipping `resolveMcpToolBindings` in `@ggui-ai/artifact-manifest`                      | `artifact-manifest/src/mcp-tool-bindings.conformance.test.ts`                                        |
 | Tool-binding search filters — `tool=` / `server=` semantics (§7.7.4.1)  | the shipping `matchesMcpToolFilters` in `@ggui-ai/registry-core`                           | `registry-core/src/mcp-tool-filters.conformance.test.ts`                                             |
+| Pre-generation refusal envelope (§7.1, refused arm)                     | the shipping `ggui_render` refusal projection in `@ggui-ai/mcp-server-handlers`            | `mcp-server-handlers/src/renders/render-refusal-projection.conformance.test.ts`                      |
+| Refusal-registry completeness (ggui#786 ruling 5b)                      | the shipping `PRE_GENERATION_REFUSAL_CODES` in `@ggui-ai/protocol`                         | this kit's own `src/registry-completeness/registry-completeness.test.ts`                             |
 
 Both WS drivers pin their pass set _and_ their skip set as exact sets, and the resource-read driver pins its skip set as exactly empty. A fixture silently degrading to a skip fails the build, and so does a skipped fixture that quietly starts passing — a skip set that can grow unnoticed is a false gate, and re-pinning it is meant to be a deliberate act.
 

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AA+BA,OAAO,EAAkB,KAAK,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAM7C,UAAU,UAAU;IAClB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB;AAED,iBAAS,SAAS,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,UAAU,CA8CtD;AAED,iBAAS,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAY3C;AAoCD,iBAAe,IAAI,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CA0D5D;AAED;;;;;;;GAOG;AACH,iBAAS,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAI/D;AA+BD,OAAO,EAAE,iBAAiB,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,CAAC"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AA+BA,OAAO,EAAkB,KAAK,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAM7C,UAAU,UAAU;IAClB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB;AAED,iBAAS,SAAS,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,UAAU,CA8CtD;AAED,iBAAS,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAY3C;AA6CD,iBAAe,IAAI,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CA0D5D;AAED;;;;;;;GAOG;AACH,iBAAS,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAI/D;AA+BD,OAAO,EAAE,iBAAiB,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,CAAC"}

package/dist/cli.js

@@ -109,11 +109,20 @@ Required:
                              session-cookie:COOKIE — Cookie header
 
 Options:
-  --only <fixture-name>    Run only this fixture. May be repeated.
+  --only <fixture-name>    Run only this fixture. May be repeated. Also
+                           filters the pure-function catalog rows, whose
+                           names are prefixed <catalog>/<case>.
   --timeout-ms <N>         Per-fixture observation window. Default 2000.
   --verbose, -v            Print failure details + skip reasons at the end.
   --help, -h               Show this help.
 
+Pure-function catalogs (refusal-envelope, registry-completeness):
+  These grade an in-process function and a data table, not the wire, so
+  the CLI cannot supply them over a URL. They appear on every scorecard
+  as SKIPPED with the reason — an ungraded obligation stays visible
+  rather than vanishing. To GRADE them, call runConformance()
+  programmatically with refusalProjector / refusalRegistry.
+
 Exit codes:
   0  — at least one fixture executed and none failed.
   1  — at least one fixture failed.

package/dist/fixtures/index.d.ts

@@ -36,6 +36,13 @@
  * frame to drive — so they do NOT belong in this behavioral fixture
  * catalog.
  *
+ * The same is true of SPEC §7.1's PRE-GENERATION refusal obligations
+ * (ggui#786): what a server projects for a refusal
+ * (`../refusal-envelope-conformance`) and what a deployment's closed
+ * refusal registry must satisfy (`../registry-completeness`) are a
+ * projection and a data check. Neither is WebSocket-observable, so
+ * neither is registered below.
+ *
  * ## An MCP-binding driver EXISTS for `resources/read` — `../resource-read-conformance`
  *
  * This catalog used to declare the MCP-binding driver as missing. It is

package/dist/fixtures/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fixtures/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AAEH,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAC1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,gCAAgC,EAAE,MAAM,uCAAuC,CAAC;AACzF,OAAO,EAAE,8BAA8B,EAAE,MAAM,qCAAqC,CAAC;AACrF,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AAExE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAQ5C;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GACpB,oBAAoB,GACpB,gBAAgB,GAChB,cAAc,GACd,4BAA4B,GAC5B,0BAA0B,GAC1B,mBAAmB,GACnB,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAElB;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,SAAS,QAAQ,EAAE,CAAC,CAOlF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,QAAQ,EAGwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fixtures/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsGG;AAEH,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAC1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,gCAAgC,EAAE,MAAM,uCAAuC,CAAC;AACzF,OAAO,EAAE,8BAA8B,EAAE,MAAM,qCAAqC,CAAC;AACrF,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AAExE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAQ5C;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GACpB,oBAAoB,GACpB,gBAAgB,GAChB,cAAc,GACd,4BAA4B,GAC5B,0BAA0B,GAC1B,mBAAmB,GACnB,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAElB;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,SAAS,QAAQ,EAAE,CAAC,CAOlF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,QAAQ,EAGwB,CAAC"}

package/dist/fixtures/index.js

@@ -36,6 +36,13 @@
  * frame to drive — so they do NOT belong in this behavioral fixture
  * catalog.
  *
+ * The same is true of SPEC §7.1's PRE-GENERATION refusal obligations
+ * (ggui#786): what a server projects for a refusal
+ * (`../refusal-envelope-conformance`) and what a deployment's closed
+ * refusal registry must satisfy (`../registry-completeness`) are a
+ * projection and a data check. Neither is WebSocket-observable, so
+ * neither is registered below.
+ *
  * ## An MCP-binding driver EXISTS for `resources/read` — `../resource-read-conformance`
  *
  * This catalog used to declare the MCP-binding driver as missing. It is

package/dist/index.d.ts

@@ -24,6 +24,10 @@ export { gadgetResolutionCases, runResolutionConformance, } from './resolution-c
 export type { GadgetUrlEntry, ResolvedGadgetUrls, ResolutionConformanceCase, ResolutionConformanceMismatch, ResolutionConformanceResult, } from './resolution-conformance/index.js';
 export { bindingFilterCases, bindingResolutionCases, runBindingFilterCases, runBindingResolutionCases, } from './binding-conformance/index.js';
 export type { BindingFilterCase, BindingFilterMismatch, BindingFilterResult, BindingManifestEntry, BindingRejectCode, BindingResolutionCase, BindingResolutionMismatch, BindingResolutionOutcome, BindingResolutionResult, McpToolBindingDecl, McpToolFilterDecl, } from './binding-conformance/index.js';
+export { refusalEnvelopeCases, runRefusalEnvelopeConformance, } from './refusal-envelope-conformance/index.js';
+export type { PreGenerationRefusalInput, ProjectedRefusalResult, RefusalEnvelopeConformanceCase, RefusalEnvelopeConformanceResult, RefusalEnvelopeMismatch, } from './refusal-envelope-conformance/index.js';
+export { registryCompletenessPins, runRegistryCompletenessConformance, } from './registry-completeness/index.js';
+export type { RefusalRegistryRow, RefusalRegistryView, RegistryCompletenessMismatch, RegistryCompletenessPin, RegistryCompletenessResult, } from './registry-completeness/index.js';
 export { declaresDeliveryChannel, renderLocatorUri, resourceReadCases, runResourceReadConformance, GGUI_RENDER_RESOURCE_URI, } from './resource-read-conformance/index.js';
 export type { DurableSubstrateWiring, JsonRpcErrorFrame, PreparedResourceReadScenario, ResourceReadCaller, ResourceReadConformanceCase, ResourceReadConformanceFailure, ResourceReadConformanceResult, ResourceReadConformanceSkip, ResourceReadErrorCodeDecl, ResourceReadExpectation, ResourceReadKey, ResourceReadLocator, ResourceReadOutcome, ResourceReadProbe, ResourceReadRenderMeta, ResourceReadScenario, ResourceReadScenarioDriver, ResourceReadSeed, ResourceReadServerShape, RunResourceReadConformanceOptions, } from './resource-read-conformance/index.js';
 export { loadFixture, listFixtures, loadAllFixtures } from './loader.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -41,6 +41,17 @@ export { gadgetResolutionCases, runResolutionConformance, } from './resolution-c
 // filter semantics (`tool=` / `server=` case-sensitive exact,
 // AND-composed per entry).
 export { bindingFilterCases, bindingResolutionCases, runBindingFilterCases, runBindingResolutionCases, } from './binding-conformance/index.js';
+// Refusal-envelope conformance — the tool result a server MUST emit for
+// a PRE-GENERATION refusal (SPEC §7.1's refused arm): an in-result
+// `isError`, the code leading the text, `{outcome, refusal}` and
+// nothing else on structuredContent, no `_meta`, and no envelope at all
+// for a code whose surfaces exclude the render gate.
+export { refusalEnvelopeCases, runRefusalEnvelopeConformance, } from './refusal-envelope-conformance/index.js';
+// Registry-completeness — the structural obligations a deployment's
+// closed refusal-code registry MUST satisfy. Grades DATA rather than a
+// function: `surfaces` non-empty, `code === key`, every `after-fix`
+// entry naming who acts, and `retry` inside the closed four-value set.
+export { registryCompletenessPins, runRegistryCompletenessConformance, } from './registry-completeness/index.js';
 // Resource-read conformance — the kit's first MCP-binding driver, and
 // it binds `resources/read` ONLY (`tools/call` has none). A read of a
 // render locator has exactly two exits: a result whose contents

package/dist/refusal-envelope-conformance/cases/refuse-after-fix-caller.json

@@ -0,0 +1,27 @@
+{
+    "name": "refuse-after-fix-caller",
+    "description": "An after-fix refusal the CALLER can act on itself: the projector emits an isError result whose text leads with the code, carries outcome 'refused' plus the refusal and nothing else, and exposes no _meta. This is the only fixBy class an agent may retry on its own.",
+    "refusal": {
+        "code": "model_not_in_tier",
+        "message": "the requested model is not among those this app may use",
+        "fix": "pick a model the app is allowed to use and call again with the same handshakeId",
+        "retry": "after-fix",
+        "handshake": "intact"
+    },
+    "expect": {
+        "isError": true,
+        "text": "model_not_in_tier: the requested model is not among those this app may use pick a model the app is allowed to use and call again with the same handshakeId",
+        "structuredContent": {
+            "outcome": "refused",
+            "refusal": {
+                "code": "model_not_in_tier",
+                "message": "the requested model is not among those this app may use",
+                "fix": "pick a model the app is allowed to use and call again with the same handshakeId",
+                "retry": "after-fix",
+                "handshake": "intact"
+            }
+        },
+        "hasMeta": false,
+        "identityFields": []
+    }
+}

package/dist/refusal-envelope-conformance/cases/refuse-after-fix-owner-with-balance.json

@@ -0,0 +1,29 @@
+{
+    "name": "refuse-after-fix-owner-with-balance",
+    "description": "An after-fix refusal whose fix belongs to the app OWNER, carrying the optional balance the refusing check read. The optional field rides the envelope unchanged \u2014 a projector must not drop it, and an agent must not auto-retry a fix it cannot perform.",
+    "refusal": {
+        "code": "insufficient_credit",
+        "message": "the balance this deployment funds the app from is exhausted",
+        "fix": "the app owner adds funds; the same handshakeId is still valid afterwards",
+        "retry": "after-fix",
+        "handshake": "intact",
+        "balanceCentsAtCheck": 0
+    },
+    "expect": {
+        "isError": true,
+        "text": "insufficient_credit: the balance this deployment funds the app from is exhausted the app owner adds funds; the same handshakeId is still valid afterwards",
+        "structuredContent": {
+            "outcome": "refused",
+            "refusal": {
+                "code": "insufficient_credit",
+                "message": "the balance this deployment funds the app from is exhausted",
+                "fix": "the app owner adds funds; the same handshakeId is still valid afterwards",
+                "retry": "after-fix",
+                "handshake": "intact",
+                "balanceCentsAtCheck": 0
+            }
+        },
+        "hasMeta": false,
+        "identityFields": []
+    }
+}

package/dist/refusal-envelope-conformance/cases/refuse-later.json

@@ -0,0 +1,27 @@
+{
+    "name": "refuse-later",
+    "description": "A transient refusal: unbounded time rather than a period boundary. Handshake intact, so the SAME id is valid on the retry the fix invites \u2014 the case exists so a projector cannot special-case the retryable class.",
+    "refusal": {
+        "code": "issuer_rate_limited",
+        "message": "calls under this issuing identity are over the rate this deployment allows",
+        "fix": "retry shortly \u2014 time restores it",
+        "retry": "later",
+        "handshake": "intact"
+    },
+    "expect": {
+        "isError": true,
+        "text": "issuer_rate_limited: calls under this issuing identity are over the rate this deployment allows retry shortly \u2014 time restores it",
+        "structuredContent": {
+            "outcome": "refused",
+            "refusal": {
+                "code": "issuer_rate_limited",
+                "message": "calls under this issuing identity are over the rate this deployment allows",
+                "fix": "retry shortly \u2014 time restores it",
+                "retry": "later",
+                "handshake": "intact"
+            }
+        },
+        "hasMeta": false,
+        "identityFields": []
+    }
+}

package/dist/refusal-envelope-conformance/cases/refuse-never.json

@@ -0,0 +1,27 @@
+{
+    "name": "refuse-never",
+    "description": "A refusal no caller action can lift. It still projects to a normal isError tool result — a terminal refusal is a wire state, never a thrown error. Carried on `billing_mode_anomaly` since registry v9 retired `tier_unrecognized`; the graded property is the `never` retry class, not the particular code.",
+    "refusal": {
+        "code": "billing_mode_anomaly",
+        "message": "the app record declares a funding mode this deployment does not recognise",
+        "fix": "no caller or owner action restores rendering under this identity; the operator reconciles the record",
+        "retry": "never",
+        "handshake": "intact"
+    },
+    "expect": {
+        "isError": true,
+        "text": "billing_mode_anomaly: the app record declares a funding mode this deployment does not recognise no caller or owner action restores rendering under this identity; the operator reconciles the record",
+        "structuredContent": {
+            "outcome": "refused",
+            "refusal": {
+                "code": "billing_mode_anomaly",
+                "message": "the app record declares a funding mode this deployment does not recognise",
+                "fix": "no caller or owner action restores rendering under this identity; the operator reconciles the record",
+                "retry": "never",
+                "handshake": "intact"
+            }
+        },
+        "hasMeta": false,
+        "identityFields": []
+    }
+}

package/dist/refusal-envelope-conformance/cases/refuse-next-period.json

@@ -0,0 +1,27 @@
+{
+    "name": "refuse-next-period",
+    "description": "A next-period refusal names no party at all \u2014 time restores it. The envelope is otherwise identical, which is the point: the retry class is data on the wire, not a different shape.",
+    "refusal": {
+        "code": "hard_cap_exceeded",
+        "message": "the app reached the hard ceiling set for the current period",
+        "fix": "the ceiling resets at the start of the next period; no action restores it sooner",
+        "retry": "next-period",
+        "handshake": "intact"
+    },
+    "expect": {
+        "isError": true,
+        "text": "hard_cap_exceeded: the app reached the hard ceiling set for the current period the ceiling resets at the start of the next period; no action restores it sooner",
+        "structuredContent": {
+            "outcome": "refused",
+            "refusal": {
+                "code": "hard_cap_exceeded",
+                "message": "the app reached the hard ceiling set for the current period",
+                "fix": "the ceiling resets at the start of the next period; no action restores it sooner",
+                "retry": "next-period",
+                "handshake": "intact"
+            }
+        },
+        "hasMeta": false,
+        "identityFields": []
+    }
+}

package/dist/refusal-envelope-conformance/cases/refuse-non-render-surface.json

@@ -0,0 +1,12 @@
+{
+    "name": "refuse-non-render-surface",
+    "description": "A REGISTERED code whose surfaces exclude the render gate. It has no render envelope at all, so a conformant projector produces nothing for it. Projecting it anyway is the drift the per-surface namespace rule forbids \u2014 this case is what makes that rule observable rather than prose.",
+    "refusal": {
+        "code": "subscription_exists",
+        "message": "an active plan already exists on this app",
+        "fix": "cancel the existing plan first, then call again",
+        "retry": "after-fix",
+        "handshake": "intact"
+    },
+    "expect": null
+}

package/dist/refusal-envelope-conformance/index.d.ts

@@ -0,0 +1,108 @@
+/**
+ * The refusal a deployment's gate returned, as the projector receives
+ * it. Authored here rather than imported from `@ggui-ai/protocol`:
+ * this is the kit's own vocabulary, and `code` is typed loosely on
+ * purpose so a catalog case can carry a registered code from ANY
+ * surface — including one that must not project.
+ */
+export interface PreGenerationRefusalInput {
+    /** A code from the deployment's refusal registry. */
+    readonly code: string;
+    /** Precise diagnostic — what was checked, against what. */
+    readonly message: string;
+    /** The one recovery step, addressed to the party that can take it. */
+    readonly fix: string;
+    /** How the call becomes possible again. */
+    readonly retry: string;
+    /** Always `intact` — a refusal reads nothing, so it consumes nothing. */
+    readonly handshake: string;
+    /** Present only when the refusing check read a balance. */
+    readonly balanceCentsAtCheck?: number;
+}
+/**
+ * The observable shape of the tool result a conformant server emits for
+ * a refusal. Deliberately flattened to the four facts the obligation is
+ * about, so an implementation in any language can report them without
+ * reproducing an MCP result object.
+ */
+export interface ProjectedRefusalResult {
+    /** MUST be true — a refusal is an in-result error, never a throw. */
+    readonly isError: boolean;
+    /** `content[0].text` — leads with the code, then message and fix. */
+    readonly text: string;
+    /** The whole `structuredContent`. */
+    readonly structuredContent: {
+        readonly outcome: string;
+        readonly refusal: PreGenerationRefusalInput;
+    };
+    /** Whether the result carries any `_meta`. MUST be false. */
+    readonly hasMeta: boolean;
+    /**
+     * Identity fields the projector put on the envelope. MUST be empty —
+     * a refusal commits nothing, so any identity field means the
+     * projection leaked state that does not exist.
+     */
+    readonly identityFields: readonly string[];
+}
+/**
+ * One refusal-envelope case. Authored as JSON under `./cases/`,
+ * consumed via {@link refusalEnvelopeCases}, graded by
+ * {@link runRefusalEnvelopeConformance}.
+ *
+ * The shape IS the public API — additive changes only.
+ */
+export interface RefusalEnvelopeConformanceCase {
+    /** Unique case name. MUST match the JSON filename without `.json`. */
+    readonly name: string;
+    /** Which projection obligation this case proves. */
+    readonly description: string;
+    /** The refusal fed to the projector. */
+    readonly refusal: PreGenerationRefusalInput;
+    /**
+     * The result a spec-conformant projector MUST produce — or `null`
+     * when the code has no render envelope at all (its registered
+     * surfaces exclude the render gate).
+     */
+    readonly expect: ProjectedRefusalResult | null;
+}
+/**
+ * Every refusal-envelope case the kit ships, in deterministic order:
+ * the projectable cases by retry class (after-fix, next-period, later,
+ * never), then the non-projectable surface case.
+ */
+export declare const refusalEnvelopeCases: readonly RefusalEnvelopeConformanceCase[];
+/** One case the projector under test graded wrong. */
+export interface RefusalEnvelopeMismatch {
+    readonly name: string;
+    /** What the catalog says a conformant projector MUST produce. */
+    readonly expected: ProjectedRefusalResult | null;
+    /**
+     * What the projector produced — or, when it THREW instead of
+     * returning, a one-line report of the throw. A gate that throws to
+     * refuse is non-conformant, so the throw is graded, never rethrown.
+     */
+    readonly actual: ProjectedRefusalResult | null | string;
+}
+/** Outcome of grading a projector against the catalog. */
+export interface RefusalEnvelopeConformanceResult {
+    /** Names of cases the projector graded correctly. */
+    readonly passed: readonly string[];
+    /** Cases the projector graded wrong — empty iff fully conformant. */
+    readonly failed: readonly RefusalEnvelopeMismatch[];
+}
+/**
+ * Grade a refusal projector against the catalog.
+ *
+ * `project` MUST be a pure computation of `(refusal) → result | null`,
+ * where `null` means "this code has no render envelope". The kit
+ * deliberately does NOT import a concrete projector — adopters pass
+ * their own. A conformant projector produces an empty `failed` array.
+ *
+ * `project` is invoked exactly once per case, in
+ * {@link refusalEnvelopeCases} order. It MUST NOT throw: throwing to
+ * refuse is precisely the non-conformance this catalog exists to
+ * catch, so a throw is recorded as a graded FAILURE on that case
+ * rather than escaping the run.
+ */
+export declare function runRefusalEnvelopeConformance(project: (refusal: PreGenerationRefusalInput) => ProjectedRefusalResult | null): RefusalEnvelopeConformanceResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/refusal-envelope-conformance/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/refusal-envelope-conformance/index.ts"],"names":[],"mappings":"AA0DA;;;;;;GAMG;AACH,MAAM,WAAW,yBAAyB;IACxC,qDAAqD;IACrD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2DAA2D;IAC3D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,sEAAsE;IACtE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,2CAA2C;IAC3C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,yEAAyE;IACzE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,2DAA2D;IAC3D,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CACvC;AAED;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,qEAAqE;IACrE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,qEAAqE;IACrE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,qCAAqC;IACrC,QAAQ,CAAC,iBAAiB,EAAE;QAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,OAAO,EAAE,yBAAyB,CAAC;KAC7C,CAAC;IACF,6DAA6D;IAC7D,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5C;AAED;;;;;;GAMG;AACH,MAAM,WAAW,8BAA8B;IAC7C,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oDAAoD;IACpD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,wCAAwC;IACxC,QAAQ,CAAC,OAAO,EAAE,yBAAyB,CAAC;IAC5C;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,sBAAsB,GAAG,IAAI,CAAC;CAChD;AAED;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,EAAE,SAAS,8BAA8B,EAOzE,CAAC;AAEF,sDAAsD;AACtD,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,iEAAiE;IACjE,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,GAAG,IAAI,CAAC;IACjD;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,sBAAsB,GAAG,IAAI,GAAG,MAAM,CAAC;CACzD;AAED,0DAA0D;AAC1D,MAAM,WAAW,gCAAgC;IAC/C,qDAAqD;IACrD,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,qEAAqE;IACrE,QAAQ,CAAC,MAAM,EAAE,SAAS,uBAAuB,EAAE,CAAC;CACrD;AAkCD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,CACP,OAAO,EAAE,yBAAyB,KAC/B,sBAAsB,GAAG,IAAI,GACjC,gCAAgC,CAwBlC"}

package/dist/refusal-envelope-conformance/index.js

@@ -0,0 +1,138 @@
+/**
+ * Refusal-envelope conformance catalog — the projection obligation for a
+ * PRE-GENERATION refusal (SPEC §7.1's refused arm, ggui#786).
+ *
+ * ## Why this is a pure-function catalog
+ *
+ * Given a refusal a deployment's gate returned, the tool result a
+ * conformant server emits is a pure, deterministic projection — no
+ * render, no transport, no wire frame. So it gets the same treatment as
+ * the wire schema (`../schema-conformance`) and the gadget URL resolver
+ * (`../resolution-conformance`): a catalog of cases graded against a
+ * caller-supplied projector.
+ *
+ * The obligation, restated from SPEC §7.1 so an implementer never has
+ * to guess:
+ *
+ *   - The result is an `isError: true` TOOL RESULT — never a thrown
+ *     error, never a JSON-RPC error. A gate that throws instead of
+ *     returning a refusal is non-conformant, which is why the runner
+ *     grades a throwing projector as a failure on every case rather
+ *     than letting the exception escape.
+ *   - `content[0].text` LEADS with the code, then the message and the
+ *     fix. A courtesy line for the model; the machine-readable code is
+ *     the mechanism.
+ *   - `structuredContent` is `{outcome: 'refused', refusal}` and
+ *     NOTHING else. A refusal commits nothing, so no identity field
+ *     may appear on it.
+ *   - No `_meta`. A refusal exposes no mount affordance.
+ *   - A code whose registered surfaces exclude the render gate has NO
+ *     render envelope; a conformant projector produces none.
+ *
+ * ## Polyglot, decoupled
+ *
+ * Each case ships as raw JSON under `./cases/`.
+ * {@link runRefusalEnvelopeConformance} takes the projector as a
+ * callback — the kit never imports a concrete server here, so adopters
+ * drive their OWN. The reference binding
+ * (`./refusal-envelope-conformance.test.ts`) builds a faithful in-test
+ * projector from `@ggui-ai/protocol` primitives only; the drift-catch
+ * against a SHIPPING projector belongs implementation-side, in the
+ * package that owns it.
+ *
+ * ## Not a WS fixture
+ *
+ * These cases are deliberately NOT registered in `fixturesByContract`.
+ * The obligation is a projection, not a WebSocket-observable behavior,
+ * so registering it there would be a permanent skip on every run —
+ * exactly the false gate the kit's exact skip-set pinning prevents.
+ * `runConformance()` / the CLI / the reporter are untouched; the entry
+ * point is the programmatic runner below.
+ */
+import refuseAfterFixCaller from './cases/refuse-after-fix-caller.json' with { type: 'json' };
+import refuseAfterFixOwnerWithBalance from './cases/refuse-after-fix-owner-with-balance.json' with { type: 'json' };
+import refuseLater from './cases/refuse-later.json' with { type: 'json' };
+import refuseNever from './cases/refuse-never.json' with { type: 'json' };
+import refuseNextPeriod from './cases/refuse-next-period.json' with { type: 'json' };
+import refuseNonRenderSurface from './cases/refuse-non-render-surface.json' with { type: 'json' };
+/**
+ * Every refusal-envelope case the kit ships, in deterministic order:
+ * the projectable cases by retry class (after-fix, next-period, later,
+ * never), then the non-projectable surface case.
+ */
+export const refusalEnvelopeCases = [
+    refuseAfterFixCaller,
+    refuseAfterFixOwnerWithBalance,
+    refuseNextPeriod,
+    refuseLater,
+    refuseNever,
+    refuseNonRenderSurface,
+];
+/** Structural equality over plain JSON data. */
+function jsonEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) {
+        return false;
+    }
+    if (Array.isArray(a) || Array.isArray(b)) {
+        if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length)
+            return false;
+        return a.every((item, index) => jsonEqual(item, b[index]));
+    }
+    const left = a;
+    const right = b;
+    const leftKeys = Object.keys(left).sort();
+    const rightKeys = Object.keys(right).sort();
+    if (!jsonEqual(leftKeys, rightKeys))
+        return false;
+    return leftKeys.every((key) => jsonEqual(left[key], right[key]));
+}
+function projectionEqual(a, b) {
+    if (a === null || b === null)
+        return a === b;
+    return (a.isError === b.isError &&
+        a.text === b.text &&
+        a.hasMeta === b.hasMeta &&
+        jsonEqual([...a.identityFields], [...b.identityFields]) &&
+        jsonEqual(a.structuredContent, b.structuredContent));
+}
+/**
+ * Grade a refusal projector against the catalog.
+ *
+ * `project` MUST be a pure computation of `(refusal) → result | null`,
+ * where `null` means "this code has no render envelope". The kit
+ * deliberately does NOT import a concrete projector — adopters pass
+ * their own. A conformant projector produces an empty `failed` array.
+ *
+ * `project` is invoked exactly once per case, in
+ * {@link refusalEnvelopeCases} order. It MUST NOT throw: throwing to
+ * refuse is precisely the non-conformance this catalog exists to
+ * catch, so a throw is recorded as a graded FAILURE on that case
+ * rather than escaping the run.
+ */
+export function runRefusalEnvelopeConformance(project) {
+    const passed = [];
+    const failed = [];
+    for (const testCase of refusalEnvelopeCases) {
+        let actual;
+        try {
+            actual = project(testCase.refusal);
+        }
+        catch (err) {
+            failed.push({
+                name: testCase.name,
+                expected: testCase.expect,
+                actual: `threw instead of returning a refusal envelope: ${err instanceof Error ? err.message : String(err)}`,
+            });
+            continue;
+        }
+        if (projectionEqual(actual, testCase.expect)) {
+            passed.push(testCase.name);
+        }
+        else {
+            failed.push({ name: testCase.name, expected: testCase.expect, actual });
+        }
+    }
+    return { passed, failed };
+}

package/dist/registry-completeness/index.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Registry-completeness catalog — the structural obligations a
+ * deployment's refusal-code registry MUST satisfy (ggui#786, ruling
+ * 5b).
+ *
+ * ## Why this is a pure-function catalog, graded differently
+ *
+ * Unlike every other catalog here, this one grades DATA rather than a
+ * function: the closed set of refusal codes a deployment declares. The
+ * caller passes the registry; each pin inspects every row and reports
+ * the rows that violate it.
+ *
+ * ## The four PORTABLE pins, and the two that are deliberately absent
+ *
+ * Ruling 5b names six checks. Four are portable — a third-party adopter
+ * with their own registry can run them, and they are the four below.
+ *
+ * Two read repo SOURCE and therefore cannot ship as conformance: the
+ * docstring rule ("an agent MUST NOT auto-retry an after-fix refusal
+ * whose fixBy is not caller") and the grep for code literals minted
+ * outside the registry file. This package publishes only `dist` +
+ * `README.md`, so a source walk could never run for an adopter, and the
+ * files that rule names live outside this tree entirely. Both live in
+ * `@ggui-ai/protocol`'s own suite, where the invariant is owned and the
+ * paths are stable. The omission is DECLARED here rather than hidden.
+ *
+ * ## Why the `fixBy` pin is one-directional
+ *
+ * The pin below asserts only that an `after-fix` row NAMES who acts. It
+ * does not assert `fixBy` is absent elsewhere, because that is a naming
+ * discipline rather than a reader-observable obligation: a reader
+ * branches on `retry`, and a `fixBy` beside a `never` misleads a human
+ * without changing what any implementation does.
+ *
+ * ggui's own registry is stricter — `fixBy` is REQUIRED on `after-fix`,
+ * PERMITTED on `later` (the operator who restores a transiently
+ * unavailable surface) and FORBIDDEN on `next-period` and `never` — and
+ * enforces it at the type level in its definer, pinned in
+ * `@ggui-ai/protocol`'s own suite. Adopters are welcome to that rule;
+ * the kit does not make it a conformance obligation. The one thing that
+ * must never happen, and IS graded here, is an `after-fix` row that
+ * does not say WHO acts — the one an agent could misread as its own to
+ * retry.
+ */
+/** One registry row, in the kit's own loose vocabulary. */
+export interface RefusalRegistryRow {
+    /** MUST equal the row's key in the registry. */
+    readonly code: string;
+    /** MUST be non-empty — the surfaces this state is refused on. */
+    readonly surfaces: readonly string[];
+    /** MUST be one of the four recognized retry classes. */
+    readonly retry: string;
+    /** Who acts. REQUIRED when `retry` is `after-fix`. */
+    readonly fixBy?: string | undefined;
+    /** Where the code is produced. */
+    readonly emitter: string;
+    /** What state the code names. */
+    readonly description: string;
+}
+/**
+ * A registry as the kit reads it: code → row. Decoupled from
+ * `@ggui-ai/protocol`'s own types on purpose — an adopter's registry is
+ * graded through this view, and a deliberately broken registry must be
+ * expressible for the negative cases.
+ */
+export type RefusalRegistryView = {
+    readonly [code: string]: RefusalRegistryRow;
+};
+/** One structural pin, applied to every row of a registry. */
+export interface RegistryCompletenessPin {
+    /** Unique pin name. */
+    readonly name: string;
+    /** The obligation this pin fixes in place. */
+    readonly description: string;
+    /**
+     * Report why `row` (declared under `code`) violates the pin, or
+     * `null` when it satisfies it.
+     */
+    readonly violation: (code: string, row: RefusalRegistryRow) => string | null;
+}
+/** Every portable pin the kit ships, in deterministic order. */
+export declare const registryCompletenessPins: readonly RegistryCompletenessPin[];
+/** One pin a registry failed, with every offending row named. */
+export interface RegistryCompletenessMismatch {
+    readonly name: string;
+    readonly description: string;
+    /** One entry per violating row: `<code>: <why>`. */
+    readonly violations: readonly string[];
+}
+/** Outcome of grading a registry against the pins. */
+export interface RegistryCompletenessResult {
+    /** Names of pins the registry satisfies. */
+    readonly passed: readonly string[];
+    /** Pins the registry violates — empty iff fully conformant. */
+    readonly failed: readonly RegistryCompletenessMismatch[];
+}
+/**
+ * Grade a refusal registry against {@link registryCompletenessPins}.
+ *
+ * Every pin is applied to every row, in declaration order; a pin passes
+ * only when NO row violates it. A conformant registry produces an empty
+ * `failed` array.
+ */
+export declare function runRegistryCompletenessConformance(registry: RefusalRegistryView): RegistryCompletenessResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/registry-completeness/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/registry-completeness/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,2DAA2D;AAC3D,MAAM,WAAW,kBAAkB;IACjC,gDAAgD;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,iEAAiE;IACjE,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,wDAAwD;IACxD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,sDAAsD;IACtD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,kCAAkC;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,iCAAiC;IACjC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,kBAAkB,CAAC;CAC7C,CAAC;AAUF,8DAA8D;AAC9D,MAAM,WAAW,uBAAuB;IACtC,uBAAuB;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8CAA8C;IAC9C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,kBAAkB,KAAK,MAAM,GAAG,IAAI,CAAC;CAC9E;AAED,gEAAgE;AAChE,eAAO,MAAM,wBAAwB,EAAE,SAAS,uBAAuB,EAoCtE,CAAC;AAEF,iEAAiE;AACjE,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,oDAAoD;IACpD,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC;AAED,sDAAsD;AACtD,MAAM,WAAW,0BAA0B;IACzC,4CAA4C;IAC5C,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,EAAE,SAAS,4BAA4B,EAAE,CAAC;CAC1D;AAED;;;;;;GAMG;AACH,wBAAgB,kCAAkC,CAChD,QAAQ,EAAE,mBAAmB,GAC5B,0BAA0B,CAiB5B"}

package/dist/registry-completeness/index.js

@@ -0,0 +1,110 @@
+/**
+ * Registry-completeness catalog — the structural obligations a
+ * deployment's refusal-code registry MUST satisfy (ggui#786, ruling
+ * 5b).
+ *
+ * ## Why this is a pure-function catalog, graded differently
+ *
+ * Unlike every other catalog here, this one grades DATA rather than a
+ * function: the closed set of refusal codes a deployment declares. The
+ * caller passes the registry; each pin inspects every row and reports
+ * the rows that violate it.
+ *
+ * ## The four PORTABLE pins, and the two that are deliberately absent
+ *
+ * Ruling 5b names six checks. Four are portable — a third-party adopter
+ * with their own registry can run them, and they are the four below.
+ *
+ * Two read repo SOURCE and therefore cannot ship as conformance: the
+ * docstring rule ("an agent MUST NOT auto-retry an after-fix refusal
+ * whose fixBy is not caller") and the grep for code literals minted
+ * outside the registry file. This package publishes only `dist` +
+ * `README.md`, so a source walk could never run for an adopter, and the
+ * files that rule names live outside this tree entirely. Both live in
+ * `@ggui-ai/protocol`'s own suite, where the invariant is owned and the
+ * paths are stable. The omission is DECLARED here rather than hidden.
+ *
+ * ## Why the `fixBy` pin is one-directional
+ *
+ * The pin below asserts only that an `after-fix` row NAMES who acts. It
+ * does not assert `fixBy` is absent elsewhere, because that is a naming
+ * discipline rather than a reader-observable obligation: a reader
+ * branches on `retry`, and a `fixBy` beside a `never` misleads a human
+ * without changing what any implementation does.
+ *
+ * ggui's own registry is stricter — `fixBy` is REQUIRED on `after-fix`,
+ * PERMITTED on `later` (the operator who restores a transiently
+ * unavailable surface) and FORBIDDEN on `next-period` and `never` — and
+ * enforces it at the type level in its definer, pinned in
+ * `@ggui-ai/protocol`'s own suite. Adopters are welcome to that rule;
+ * the kit does not make it a conformance obligation. The one thing that
+ * must never happen, and IS graded here, is an `after-fix` row that
+ * does not say WHO acts — the one an agent could misread as its own to
+ * retry.
+ */
+/** The four recognized retry classes (ggui#786 rulings v2 + v4). */
+const RECOGNIZED_RETRIES = [
+    'after-fix',
+    'next-period',
+    'later',
+    'never',
+];
+/** Every portable pin the kit ships, in deterministic order. */
+export const registryCompletenessPins = [
+    {
+        name: 'surfaces-non-empty',
+        description: 'Every entry lists at least one surface it is emitted on. A row nobody emits anywhere is a name reserved with no obligation behind it, which is the drift a closed registry exists to prevent. One code MAY list several surfaces — one state can surface in more than one place.',
+        violation: (_code, row) => row.surfaces.length > 0 ? null : 'surfaces is empty',
+    },
+    {
+        name: 'code-equals-key',
+        description: "Every entry's `code` equals the key it is declared under. The key is what emitters look a row up by and the code is what reaches the wire; if they disagree, the registry stops being the single namespace it claims to be.",
+        violation: (code, row) => row.code === code ? null : `code '${row.code}' does not equal key '${code}'`,
+    },
+    {
+        name: 'after-fix-names-fixby',
+        description: "Every `after-fix` entry names WHO acts, in `fixBy`. Without it, 'retry after the fix' cannot be told apart from 'retry now' — and an agent may only act on a fix that is its own. A row whose `retry` is not a recognized class ALSO fails this pin: the obligation is undecidable for it, and a pin that silently passes a row it could not evaluate is a false gate.",
+        violation: (_code, row) => {
+            if (!RECOGNIZED_RETRIES.includes(row.retry)) {
+                return `retry '${row.retry}' is not a recognized class, so the fixBy obligation cannot be evaluated`;
+            }
+            if (row.retry !== 'after-fix')
+                return null;
+            return row.fixBy === undefined ? 'after-fix entry carries no fixBy' : null;
+        },
+    },
+    {
+        name: 'retry-in-closed-set',
+        description: "Every entry's `retry` is one of `after-fix`, `next-period`, `later`, `never`. The class is what a reader branches on to decide whether to wait, act, or stop; an unrecognized value leaves it with no defined behaviour.",
+        violation: (_code, row) => RECOGNIZED_RETRIES.includes(row.retry)
+            ? null
+            : `retry '${row.retry}' is outside the closed set`,
+    },
+];
+/**
+ * Grade a refusal registry against {@link registryCompletenessPins}.
+ *
+ * Every pin is applied to every row, in declaration order; a pin passes
+ * only when NO row violates it. A conformant registry produces an empty
+ * `failed` array.
+ */
+export function runRegistryCompletenessConformance(registry) {
+    const entries = Object.entries(registry);
+    const passed = [];
+    const failed = [];
+    for (const pin of registryCompletenessPins) {
+        const violations = [];
+        for (const [code, row] of entries) {
+            const why = pin.violation(code, row);
+            if (why !== null)
+                violations.push(`${code}: ${why}`);
+        }
+        if (violations.length === 0) {
+            passed.push(pin.name);
+        }
+        else {
+            failed.push({ name: pin.name, description: pin.description, violations });
+        }
+    }
+    return { passed, failed };
+}

package/dist/reporter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reporter.d.ts","sourceRoot":"","sources":["../src/reporter.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EACjB,cAAc,EACf,MAAM,sBAAsB,CAAC;AAM9B,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,GAAE,sBAA2B,GACnC,mBAAmB,CA0CrB;AAMD,wBAAgB,eAAe,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAmBjE;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAW/D;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,GAAG,MAAM,CAW9E;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,GAAG,MAAM,CAStE"}
+{"version":3,"file":"reporter.d.ts","sourceRoot":"","sources":["../src/reporter.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EACjB,cAAc,EACf,MAAM,sBAAsB,CAAC;AAM9B,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,GAAE,sBAA2B,GACnC,mBAAmB,CA0CrB;AAMD,wBAAgB,eAAe,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAejE;AAyBD,wBAAgB,aAAa,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAW/D;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,GAAG,MAAM,CAW9E;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,GAAG,MAAM,CAStE"}

package/dist/reporter.js

@@ -14,6 +14,7 @@
  * `reporter` config.
  */
 import { fixturesByContract } from './fixtures/index.js';
+import { PURE_FUNCTION_CATALOG_SLUGS } from './run-conformance.js';
 /**
  * Build a {@link ConformanceReporter} that writes the bar-scorecard
  * report. The return value plugs directly into
@@ -69,21 +70,37 @@ export function createDefaultReporter(options = {}) {
 // =============================================================================
 export function formatScorecard(result) {
     // Group fixtures by contract so operators see pass rates per
-    // criterion, mirroring `fixturesByContract`'s classification.
+    // criterion, mirroring `fixturesByContract`'s classification, then
+    // the pure-function catalogs, whose rows carry a `<slug>/` prefix
+    // instead of living in that map (they are not WS-observable).
     const lines = [];
     for (const [slug, fixtures] of Object.entries(fixturesByContract)) {
         const names = new Set(fixtures.map((f) => f.name));
-        const passedCount = result.passed.filter((n) => names.has(n)).length;
-        const failedCount = result.failed.filter((f) => names.has(f.name)).length;
-        const skippedCount = result.skipped.filter((s) => names.has(s.name)).length;
-        const total = passedCount + failedCount + skippedCount;
-        if (total === 0)
-            continue;
-        const tone = failedCount > 0 ? MARK_FAIL : passedCount > 0 ? MARK_PASS : MARK_SKIP;
-        lines.push(`  ${tone}  ${padRight(slug, 38)}  ${passedCount}/${total} pass${failedCount > 0 ? ` · ${failedCount} fail` : ''}${skippedCount > 0 ? ` · ${skippedCount} skip` : ''}`);
+        lines.push(...scorecardRow(slug, result, (name) => names.has(name)));
+    }
+    for (const slug of PURE_FUNCTION_CATALOG_SLUGS) {
+        const prefix = `${slug}/`;
+        lines.push(...scorecardRow(slug, result, (name) => name.startsWith(prefix)));
     }
     return lines.join('\n');
 }
+/**
+ * One scorecard line for the rows `belongs` selects, or no line at all
+ * when the group graded nothing. A group that is entirely SKIPPED still
+ * prints — an obligation nobody graded must be visible, not absent.
+ */
+function scorecardRow(slug, result, belongs) {
+    const passedCount = result.passed.filter(belongs).length;
+    const failedCount = result.failed.filter((f) => belongs(f.name)).length;
+    const skippedCount = result.skipped.filter((s) => belongs(s.name)).length;
+    const total = passedCount + failedCount + skippedCount;
+    if (total === 0)
+        return [];
+    const tone = failedCount > 0 ? MARK_FAIL : passedCount > 0 ? MARK_PASS : MARK_SKIP;
+    return [
+        `  ${tone}  ${padRight(slug, 38)}  ${passedCount}/${total} pass${failedCount > 0 ? ` · ${failedCount} fail` : ''}${skippedCount > 0 ? ` · ${skippedCount} skip` : ''}`,
+    ];
+}
 export function formatSummary(result) {
     const passed = result.passed.length;
     const failed = result.failed.length;

package/dist/run-conformance.d.ts

@@ -2,6 +2,8 @@ import type { HostContextObservedPayload } from '@ggui-ai/protocol';
 import type { ConformanceHost, SetupStep as HostSetupStep } from './conformance-host.js';
 import { type MatchResult } from './match-behavior.js';
 import type { AuthConfig, SessionStateBehavior, StreamUpdateBehavior, VersionMismatchBehavior } from './types.js';
+import { type PreGenerationRefusalInput, type ProjectedRefusalResult } from './refusal-envelope-conformance/index.js';
+import { type RefusalRegistryView } from './registry-completeness/index.js';
 export interface RunConformanceConfig {
     /**
      * URL of the implementation under test. `http://` / `https://`
@@ -27,7 +29,34 @@ export interface RunConformanceConfig {
     readonly host?: ConformanceHost;
     /** Per-fixture observation window. Default 2000ms. */
     readonly observationTimeoutMs?: number;
+    /**
+     * The implementation's PRE-GENERATION refusal projector (SPEC §7.1's
+     * refused arm). Given a refusal, return the tool result the server
+     * would emit for it, or `null` when the code has no envelope on this
+     * surface.
+     *
+     * Supplied ⇒ the `refusal-envelope` catalog is graded as part of this
+     * run. Omitted ⇒ its cases are reported SKIPPED with that reason, so
+     * an ungraded obligation shows up on the scorecard instead of
+     * vanishing from it.
+     */
+    readonly refusalProjector?: (refusal: PreGenerationRefusalInput) => ProjectedRefusalResult | null;
+    /**
+     * The deployment's closed refusal-code registry, keyed by code.
+     * Supplied ⇒ the `registry-completeness` pins are graded as part of
+     * this run; omitted ⇒ reported SKIPPED, same reasoning as above.
+     */
+    readonly refusalRegistry?: RefusalRegistryView;
 }
+/**
+ * Row-name prefixes for the PURE-FUNCTION catalogs the runner folds
+ * into a run. Prefixed so a catalog row can never collide with a
+ * WebSocket fixture name, and so the reporter can group them without a
+ * second registry of names.
+ */
+export declare const PURE_FUNCTION_CATALOG_SLUGS: readonly ["refusal-envelope", "registry-completeness"];
+/** One member of {@link PURE_FUNCTION_CATALOG_SLUGS}. */
+export type PureFunctionCatalogSlug = (typeof PURE_FUNCTION_CATALOG_SLUGS)[number];
 export interface ConformanceResult {
     readonly passed: readonly string[];
     readonly failed: readonly ConformanceFailure[];

package/dist/run-conformance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-conformance.d.ts","sourceRoot":"","sources":["../src/run-conformance.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"run-conformance.d.ts","sourceRoot":"","sources":["../src/run-conformance.ts"],"names":[],"mappings":"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"}

package/dist/run-conformance.js

@@ -46,17 +46,35 @@
  *         (No teardown vocabulary exists in this kit version, so the
  *         loop is empty today.)
  *      l. Record the outcome via reporter + accumulate in result.
- *   3. Invoke `reporter.onComplete(result)` + return.
+ *   3. Fold in the PURE-FUNCTION catalogs (ggui#786) —
+ *      `refusal-envelope` and `registry-completeness`. They grade a
+ *      caller-supplied projector / registry rather than the wire, so
+ *      they need no transport; when the caller supplies neither, their
+ *      rows are reported SKIPPED with that reason so an ungraded
+ *      obligation stays visible on the scorecard.
+ *   4. Invoke `reporter.onComplete(result)` + return.
  *
- * Scope v1: pure WS transport. Browser-level fixtures (bootstrap-
- * failure, props-update) automatically skip via the matcher's
- * `unmatchable-on-ws` arm.
+ * Scope v1: pure WS transport for the fixture catalog. Browser-level
+ * fixtures (bootstrap-failure, props-update) automatically skip via the
+ * matcher's `unmatchable-on-ws` arm.
  */
 import { PROTOCOL_SCHEMA_VERSION } from '@ggui-ai/protocol';
 import { allFixtures, fixturesByContract } from './fixtures/index.js';
 import { isRecord } from '@ggui-ai/protocol';
 import { behaviorIs, deepEqual, matchBehavior } from './match-behavior.js';
 import { openWsTransport } from './ws-transport.js';
+import { refusalEnvelopeCases, runRefusalEnvelopeConformance, } from './refusal-envelope-conformance/index.js';
+import { registryCompletenessPins, runRegistryCompletenessConformance, } from './registry-completeness/index.js';
+/**
+ * Row-name prefixes for the PURE-FUNCTION catalogs the runner folds
+ * into a run. Prefixed so a catalog row can never collide with a
+ * WebSocket fixture name, and so the reporter can group them without a
+ * second registry of names.
+ */
+export const PURE_FUNCTION_CATALOG_SLUGS = [
+    'refusal-envelope',
+    'registry-completeness',
+];
 // =============================================================================
 // Runner
 // =============================================================================
@@ -93,6 +111,7 @@ export async function runConformance(config) {
                 break;
         }
     }
+    runPureFunctionCatalogs(config, reporter, { passed, failed, skipped });
     const result = {
         passed,
         failed,
@@ -102,6 +121,85 @@ export async function runConformance(config) {
     reporter.onComplete?.(result);
     return result;
 }
+/**
+ * Fold the pure-function catalogs (ggui#786) into a run.
+ *
+ * These obligations are not WebSocket-observable — a refusal projection
+ * is a pure function and a registry is data — so they are NOT in
+ * `fixturesByContract` (see `fixtures/index.ts` for why registering a
+ * non-WS case there would be a permanent skip). But leaving them
+ * reachable only through a direct import made them invisible to every
+ * CLI run: a catalog the runner cannot report is a silent gate
+ * (docs/principles/no-silent-block.md).
+ *
+ * So they run HERE, on the same verdict buckets as the fixtures, and an
+ * absent input produces a SKIP row naming what to supply rather than
+ * nothing at all.
+ */
+function runPureFunctionCatalogs(config, reporter, buckets) {
+    const only = config.only;
+    const wanted = (name) => only === undefined || only.length === 0 || only.includes(name);
+    const pass = (name) => {
+        if (!wanted(name))
+            return;
+        buckets.passed.push(name);
+        reporter.onFixturePass?.(name, 0);
+    };
+    const skip = (name, reason) => {
+        if (!wanted(name))
+            return;
+        buckets.skipped.push({ name, reason });
+        reporter.onFixtureSkip?.(name, reason);
+    };
+    const fail = (failure) => {
+        if (!wanted(failure.name))
+            return;
+        buckets.failed.push(failure);
+        reporter.onFixtureFail?.(failure);
+    };
+    // ── refusal-envelope ──
+    const projector = config.refusalProjector;
+    if (projector === undefined) {
+        for (const testCase of refusalEnvelopeCases) {
+            skip(`refusal-envelope/${testCase.name}`, 'no `refusalProjector` supplied — pass one to runConformance() to grade SPEC §7.1\u2019s refused arm');
+        }
+    }
+    else {
+        const envelope = runRefusalEnvelopeConformance(projector);
+        for (const name of envelope.passed)
+            pass(`refusal-envelope/${name}`);
+        for (const mismatch of envelope.failed) {
+            fail({
+                name: `refusal-envelope/${mismatch.name}`,
+                criterion: 'pre-generation refusal envelope (SPEC §7.1, refused arm)',
+                expected: mismatch.expected,
+                received: mismatch.actual,
+                message: 'the projected refusal envelope does not match the catalog case',
+            });
+        }
+    }
+    // ── registry-completeness ──
+    const registry = config.refusalRegistry;
+    if (registry === undefined) {
+        for (const pin of registryCompletenessPins) {
+            skip(`registry-completeness/${pin.name}`, 'no `refusalRegistry` supplied — pass the deployment\u2019s refusal-code registry to runConformance() to grade it');
+        }
+    }
+    else {
+        const completeness = runRegistryCompletenessConformance(registry);
+        for (const name of completeness.passed)
+            pass(`registry-completeness/${name}`);
+        for (const mismatch of completeness.failed) {
+            fail({
+                name: `registry-completeness/${mismatch.name}`,
+                criterion: 'refusal-registry completeness',
+                expected: mismatch.description,
+                received: mismatch.violations,
+                message: `${String(mismatch.violations.length)} row(s) violate this pin`,
+            });
+        }
+    }
+}
 async function runOneFixture(fixture, config, _reporter) {
     const fixtureStarted = Date.now();
     if (fixture.skipReason !== null) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ggui-ai/protocol-conformance",
-  "version": "0.13.0",
-  "description": "Conformance test kit for the ggui protocol. Drives a behavioral fixture catalog against a live implementation over WebSocket, a resources/read catalog against a live MCP server, and six pure-function catalogs (schema, registration, resolution, binding, props-schema, host-helper) for the gadget, tool-binding, and schema-precise-render and host-helper obligations, reporting a scorecard-style pass / fail / skip. MCP builders adopt this kit to prove their implementation is protocol-conformant.",
+  "version": "0.14.0",
+  "description": "Conformance test kit for the ggui protocol. Drives a behavioral fixture catalog against a live implementation over WebSocket, a resources/read catalog against a live MCP server, and eight pure-function catalogs (schema, registration, resolution, binding, props-schema, host-helper, refusal-envelope, registry-completeness) for the gadget, tool-binding, schema-precise-render, host-helper and pre-generation-refusal obligations, reporting a scorecard-style pass / fail / skip. MCP builders adopt this kit to prove their implementation is protocol-conformant.",
   "license": "Apache-2.0",
   "keywords": [
     "ggui",
@@ -65,11 +65,21 @@
       "types": "./dist/host-helper-conformance/index.d.ts",
       "import": "./dist/host-helper-conformance/index.js",
       "default": "./dist/host-helper-conformance/index.js"
+    },
+    "./refusal-envelope-conformance": {
+      "types": "./dist/refusal-envelope-conformance/index.d.ts",
+      "import": "./dist/refusal-envelope-conformance/index.js",
+      "default": "./dist/refusal-envelope-conformance/index.js"
+    },
+    "./registry-completeness": {
+      "types": "./dist/registry-completeness/index.d.ts",
+      "import": "./dist/registry-completeness/index.js",
+      "default": "./dist/registry-completeness/index.js"
     }
   },
   "dependencies": {
     "ws": "^8.20.1",
-    "@ggui-ai/protocol": "0.13.0"
+    "@ggui-ai/protocol": "0.14.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
@@ -90,11 +100,11 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=22.0.0"
   },
   "author": "ggui contributors <hello@ggui.ai>",
   "scripts": {
-    "build": "rm -rf dist.staging && tsc -p tsconfig.build.json --outDir dist.staging && node ../scripts/fix-esm-imports.mjs dist.staging && chmod +x dist.staging/cli.js && node ../scripts/atomic-swap.mjs dist.staging dist",
+    "build": "rm -rf dist.staging-$$ && tsc -p tsconfig.build.json --outDir dist.staging-$$ && node ../scripts/fix-esm-imports.mjs dist.staging-$$ && chmod +x dist.staging-$$/cli.js && node ../scripts/atomic-swap.mjs dist.staging-$$ dist",
     "dev": "tsc --watch",
     "typecheck": "tsc --noEmit",
     "test": "vitest run --passWithNoTests",