@vizejs/marquette 0.299.1

package/README.md

@@ -0,0 +1,129 @@
+# `@vizejs/marquette`
+
+Typed application marquettes for every Vize target.
+
+> Experimental: serialized contracts are versioned, but the TypeScript API may
+> evolve while target adapters are being validated.
+
+Marquette is the small, language-neutral description shared by web, native,
+desktop, terminal, backend, transport, testing, and gallery tooling. This
+package provides literal-preserving TypeScript authoring. Runtime validation is
+available through a separate entry, while canonicalization and compatibility
+analysis remain focused layers.
+
+## Author a marquette
+
+```ts
+import { defineApplicationMarquette } from "@vizejs/marquette";
+
+export default defineApplicationMarquette({
+  application: "shop",
+  targets: ["web", "native"],
+  environments: [
+    {
+      id: "web",
+      target: "web",
+      consumer: "client",
+      runtime: "browser",
+    },
+    {
+      id: "native",
+      target: "native",
+      consumer: "client",
+      runtime: "native",
+    },
+    {
+      id: "server",
+      target: "web",
+      consumer: "server",
+      runtime: "rust",
+    },
+  ],
+  backends: [
+    {
+      id: "api",
+      family: "rust",
+      environment: "server",
+    },
+  ],
+  protocols: [
+    {
+      id: "api.query",
+      family: "schema-query",
+      backend: "api",
+    },
+  ],
+  routes: [
+    {
+      id: "home",
+      path: "/",
+      environment: "web",
+      rendering: "hybrid",
+      backend: "api",
+      protocol: "api.query",
+    },
+  ],
+});
+```
+
+Environment dependencies, backend owners, protocol owners, and route
+references are checked against identifiers declared in the same object. A
+misspelled reference is therefore an authoring error rather than a runtime
+surprise.
+
+## Runtime validation
+
+Use the dedicated validation entry when contracts cross file, process, or
+language boundaries:
+
+```ts
+import { validateApplicationMarquette } from "@vizejs/marquette/validate";
+
+const diagnostics = validateApplicationMarquette(shop);
+for (const diagnostic of diagnostics) {
+  console.error(diagnostic.code, diagnostic.path, diagnostic.message);
+}
+```
+
+Validation is deterministic, does not mutate the authored object, and reports
+stable codes shared with the native contract implementation. Keeping it in a
+separate entry means authoring-only applications do not include validation
+code.
+
+## Test-run evidence
+
+Release-bound test-run evidence records live in their own lazy entries so
+deployment tooling can bind a `tests` check to retained, immutable facts:
+
+```ts
+import { defineTestRunEvidence } from "@vizejs/marquette/test-run";
+import { validateTestRunEvidence } from "@vizejs/marquette/test-run/validate";
+import { testRunAdmissionId } from "@vizejs/marquette/test-run/canonical";
+import { admitTestRun } from "@vizejs/marquette/test-run/admission";
+
+const diagnostics = validateTestRunEvidence(evidence);
+const admissionId = await testRunAdmissionId(evidence); // test-run:<sha256>
+const rejections = await admitTestRun(evidence, candidate, admissionId, now);
+```
+
+Validation shares its `VIZE_MARQUETTE_1xx` codes, paths, and ordering with the
+native implementation, and the canonical entry produces byte-identical
+serialization and SHA-256 fingerprints, proven by the shared fixtures in
+`tests/fixtures/test-run-evidence/`. The published record schema is available
+from `@vizejs/marquette/test-run/schema`.
+
+## Guarantees
+
+- Exact identifiers remain available as `EnvironmentId`, `BackendId`,
+  `ProtocolId`, and `RouteId` unions.
+- `defineApplicationMarquette` returns its input without allocation or
+  normalization.
+- The published application-contract schema is available from
+  `@vizejs/marquette/schema`.
+- Every optional contract field documents its default in JSDoc.
+- Package builds enforce a 1 KiB gzip budget for authoring entries and 3 KiB
+  or 4 KiB budgets for the validation entries.
+
+Marquette describes components and environments; it does not author UI
+components. Public Vize UI components use real `.vue` SFC files as their
+canonical source, never authored `h()` calls or handwritten render functions.

package/dist/index.d.mts

@@ -0,0 +1,52 @@
+import { _ as RouteId, a as CapabilityId, b as TargetId, c as MARQUETTE_FORMAT_VERSION, d as MarquetteProtocol, f as MarquetteRoute, g as RenderingMode, h as ProtocolId, i as CapabilityDefinition, l as MarquetteBackend, m as ProtocolFamily, n as BackendFamily, o as EnvironmentConsumer, p as MarquetteTarget, r as BackendId, s as EnvironmentId, t as ApplicationMarquette, u as MarquetteEnvironment, v as RuntimeFamily, y as ServerEnvironmentId } from "./model-DWcxWbC1.mjs";
+
+//#region src/author.d.ts
+/**
+ * Cross-reference constraints derived from the literals in one marquette.
+ *
+ * Keeping this type separate makes editor diagnostics point at the authored
+ * reference instead of widening every identifier to `string`.
+ */
+type MarquetteReferenceConstraints<Marquette extends ApplicationMarquette> = {
+  readonly capabilities?: { readonly [Id in CapabilityId<Marquette>]: CapabilityDefinition & {
+    readonly id: Id;
+  } };
+  readonly environments?: readonly (MarquetteEnvironment<string, EnvironmentId<Marquette>> & {
+    readonly capabilities?: readonly CapabilityId<Marquette>[];
+    readonly target: TargetId<Marquette>;
+  })[];
+  readonly backends?: readonly (MarquetteBackend<string, ServerEnvironmentId<Marquette>> & {
+    readonly capabilities?: readonly CapabilityId<Marquette>[];
+  })[];
+  readonly protocols?: readonly (MarquetteProtocol<string, BackendId<Marquette>> & {
+    readonly capabilities?: readonly CapabilityId<Marquette>[];
+  })[];
+  readonly routes?: readonly (MarquetteRoute<string, EnvironmentId<Marquette>, BackendId<Marquette>, ProtocolId<Marquette>> & {
+    readonly capabilities?: readonly CapabilityId<Marquette>[];
+  })[];
+};
+/**
+ * Defines an application marquette while preserving every authored literal.
+ *
+ * Environment dependencies, backend owners, protocol owners, and route
+ * references are checked against identifiers declared in the same object.
+ * The function returns its input without allocation or runtime work.
+ *
+ * @example
+ * ```ts
+ * const app = defineApplicationMarquette({
+ *   application: "shop",
+ *   targets: ["web"],
+ *   environments: [
+ *     { id: "web", target: "web", consumer: "client", runtime: "browser" },
+ *   ],
+ *   routes: [
+ *     { id: "home", path: "/", environment: "web", rendering: "client" },
+ *   ],
+ * });
+ * ```
+ */
+declare function defineApplicationMarquette<const Marquette extends ApplicationMarquette>(marquette: Marquette & MarquetteReferenceConstraints<NoInfer<Marquette>>): Marquette;
+//#endregion
+export { type ApplicationMarquette, type BackendFamily, type BackendId, type CapabilityDefinition, type CapabilityId, type EnvironmentConsumer, type EnvironmentId, MARQUETTE_FORMAT_VERSION, type MarquetteBackend, type MarquetteEnvironment, type MarquetteProtocol, type MarquetteReferenceConstraints, type MarquetteRoute, type MarquetteTarget, type ProtocolFamily, type ProtocolId, type RenderingMode, type RouteId, type RuntimeFamily, type ServerEnvironmentId, type TargetId, defineApplicationMarquette };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/author.ts"],"mappings":";;;;;AAqBA;;;;KAAY,6BAAA,mBAAgD,oBAAA;EAAA,SACjD,YAAA,qBACS,YAAA,CAAa,SAAA,IAAa,oBAAA;IAAA,SAAkC,EAAA,EAAI,EAAA;EAAA;EAAA,SAEzE,YAAA,aAAyB,oBAAA,SAA6B,aAAA,CAAc,SAAA;IAAA,SAClE,YAAA,YAAwB,YAAA,CAAa,SAAA;IAAA,SACrC,MAAA,EAAQ,QAAA,CAAS,SAAA;EAAA;EAAA,SAEnB,QAAA,aAAqB,gBAAA,SAAyB,mBAAA,CAAoB,SAAA;IAAA,SAChE,YAAA,YAAwB,YAAA,CAAa,SAAA;EAAA;EAAA,SAEvC,SAAA,aAAsB,iBAAA,SAA0B,SAAA,CAAU,SAAA;IAAA,SACxD,YAAA,YAAwB,YAAA,CAAa,SAAA;EAAA;EAAA,SAEvC,MAAA,aAAmB,cAAA,SAE1B,aAAA,CAAc,SAAA,GACd,SAAA,CAAU,SAAA,GACV,UAAA,CAAW,SAAA;IAAA,SACE,YAAA,YAAwB,YAAA,CAAa,SAAA;EAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;iBAwBtC,0BAAA,yBAAmD,oBAAA,CAAA,CACjE,SAAA,EAAW,SAAA,GAAY,6BAAA,CAA8B,OAAA,CAAQ,SAAA,KAC5D,SAAA"}

package/dist/index.mjs

@@ -0,0 +1,33 @@
+//#region src/author.ts
+/**
+* Defines an application marquette while preserving every authored literal.
+*
+* Environment dependencies, backend owners, protocol owners, and route
+* references are checked against identifiers declared in the same object.
+* The function returns its input without allocation or runtime work.
+*
+* @example
+* ```ts
+* const app = defineApplicationMarquette({
+*   application: "shop",
+*   targets: ["web"],
+*   environments: [
+*     { id: "web", target: "web", consumer: "client", runtime: "browser" },
+*   ],
+*   routes: [
+*     { id: "home", path: "/", environment: "web", rendering: "client" },
+*   ],
+* });
+* ```
+*/
+function defineApplicationMarquette(marquette) {
+	return marquette;
+}
+//#endregion
+//#region src/model.ts
+/** Current serialized application-marquette format. */
+const MARQUETTE_FORMAT_VERSION = 1;
+//#endregion
+export { MARQUETTE_FORMAT_VERSION, defineApplicationMarquette };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/author.ts","../src/model.ts"],"sourcesContent":["import type {\n  ApplicationMarquette,\n  BackendId,\n  CapabilityDefinition,\n  CapabilityId,\n  EnvironmentId,\n  MarquetteBackend,\n  MarquetteEnvironment,\n  MarquetteProtocol,\n  MarquetteRoute,\n  ProtocolId,\n  ServerEnvironmentId,\n  TargetId,\n} from \"./model.js\";\n\n/**\n * Cross-reference constraints derived from the literals in one marquette.\n *\n * Keeping this type separate makes editor diagnostics point at the authored\n * reference instead of widening every identifier to `string`.\n */\nexport type MarquetteReferenceConstraints<Marquette extends ApplicationMarquette> = {\n  readonly capabilities?: {\n    readonly [Id in CapabilityId<Marquette>]: CapabilityDefinition & { readonly id: Id };\n  };\n  readonly environments?: readonly (MarquetteEnvironment<string, EnvironmentId<Marquette>> & {\n    readonly capabilities?: readonly CapabilityId<Marquette>[];\n    readonly target: TargetId<Marquette>;\n  })[];\n  readonly backends?: readonly (MarquetteBackend<string, ServerEnvironmentId<Marquette>> & {\n    readonly capabilities?: readonly CapabilityId<Marquette>[];\n  })[];\n  readonly protocols?: readonly (MarquetteProtocol<string, BackendId<Marquette>> & {\n    readonly capabilities?: readonly CapabilityId<Marquette>[];\n  })[];\n  readonly routes?: readonly (MarquetteRoute<\n    string,\n    EnvironmentId<Marquette>,\n    BackendId<Marquette>,\n    ProtocolId<Marquette>\n  > & { readonly capabilities?: readonly CapabilityId<Marquette>[] })[];\n};\n\n/**\n * Defines an application marquette while preserving every authored literal.\n *\n * Environment dependencies, backend owners, protocol owners, and route\n * references are checked against identifiers declared in the same object.\n * The function returns its input without allocation or runtime work.\n *\n * @example\n * ```ts\n * const app = defineApplicationMarquette({\n *   application: \"shop\",\n *   targets: [\"web\"],\n *   environments: [\n *     { id: \"web\", target: \"web\", consumer: \"client\", runtime: \"browser\" },\n *   ],\n *   routes: [\n *     { id: \"home\", path: \"/\", environment: \"web\", rendering: \"client\" },\n *   ],\n * });\n * ```\n */\nexport function defineApplicationMarquette<const Marquette extends ApplicationMarquette>(\n  marquette: Marquette & MarquetteReferenceConstraints<NoInfer<Marquette>>,\n): Marquette {\n  return marquette;\n}\n","/** Current serialized application-marquette format. */\nexport const MARQUETTE_FORMAT_VERSION = 1 as const;\n\n/** User-visible target produced by an application marquette. */\nexport type MarquetteTarget = \"web\" | \"native\" | \"desktop\" | \"terminal\";\n\n/** Runtime family that executes one environment. */\nexport type RuntimeFamily =\n  | \"browser\"\n  | \"javascript\"\n  | \"rust\"\n  | \"go\"\n  | \"jvm\"\n  | \"native\"\n  | \"desktop\"\n  | \"terminal\"\n  | \"external\";\n\n/** Side of the application graph that consumes an environment. */\nexport type EnvironmentConsumer = \"client\" | \"server\";\n\n/** Backend implementation family selected by an application. */\nexport type BackendFamily = \"javascript\" | \"rust\" | \"go\" | \"jvm\" | \"external\";\n\n/** Semantic family used by one data or procedure endpoint. */\nexport type ProtocolFamily = \"schema-query\" | \"typed-rpc\" | \"binary-rpc\";\n\n/** Rendering strategy selected for one route or target view. */\nexport type RenderingMode =\n  | \"client\"\n  | \"static\"\n  | \"server\"\n  | \"stream\"\n  | \"partial\"\n  | \"hybrid\"\n  | \"native\"\n  | \"desktop\"\n  | \"terminal\";\n\n/** Versioned capability understood by adapters and developer tools. */\nexport interface CapabilityDefinition {\n  /** Stable lowercase capability identifier. */\n  readonly id: string;\n  /** Summary shown by diagnostics, documentation, and AI tooling. */\n  readonly description: string;\n  /**\n   * Capability contract version.\n   *\n   * @default 1\n   */\n  readonly version?: number;\n}\n\n/** Independently transformed and cached application environment. */\nexport interface MarquetteEnvironment<\n  Id extends string = string,\n  DependencyId extends string = string,\n> {\n  /** Stable identifier, unique within the application. */\n  readonly id: Id;\n  /** User-visible target served by this environment. */\n  readonly target: MarquetteTarget;\n  /** Whether output is consumed by an end user or a trusted runtime. */\n  readonly consumer: EnvironmentConsumer;\n  /** Runtime family that executes the output. */\n  readonly runtime: RuntimeFamily;\n  /**\n   * Authored entry module.\n   *\n   * @default undefined\n   */\n  readonly entry?: string;\n  /**\n   * Environments that must build first.\n   *\n   * @default []\n   */\n  readonly dependsOn?: readonly DependencyId[];\n  /**\n   * Capabilities required from the environment adapter.\n   *\n   * @default []\n   */\n  readonly capabilities?: readonly string[];\n}\n\n/** Backend application or independently deployed service. */\nexport interface MarquetteBackend<\n  Id extends string = string,\n  EnvironmentId extends string = string,\n> {\n  /** Stable backend identifier. */\n  readonly id: Id;\n  /** Backend implementation family. */\n  readonly family: BackendFamily;\n  /**\n   * Server environment that owns local execution.\n   *\n   * @default undefined\n   */\n  readonly environment?: EnvironmentId;\n  /**\n   * Capabilities required from the backend adapter.\n   *\n   * @default []\n   */\n  readonly capabilities?: readonly string[];\n}\n\n/** Protocol endpoint exposed by a backend. */\nexport interface MarquetteProtocol<Id extends string = string, BackendId extends string = string> {\n  /** Stable endpoint identifier. */\n  readonly id: Id;\n  /** Protocol semantic family. */\n  readonly family: ProtocolFamily;\n  /** Backend that owns the endpoint. */\n  readonly backend: BackendId;\n  /**\n   * Capabilities required from the protocol adapter.\n   *\n   * @default []\n   */\n  readonly capabilities?: readonly string[];\n}\n\n/** Typed application route or target view. */\nexport interface MarquetteRoute<\n  Id extends string = string,\n  EnvironmentId extends string = string,\n  BackendId extends string = string,\n  ProtocolId extends string = string,\n> {\n  /** Stable identifier used by generated navigation APIs. */\n  readonly id: Id;\n  /** Logical path, always beginning with `/`. */\n  readonly path: `/${string}`;\n  /** Environment that owns the rendered route. */\n  readonly environment: EnvironmentId;\n  /** Rendering strategy used by the route. */\n  readonly rendering: RenderingMode;\n  /**\n   * Backend used by data loading, mutations, or server rendering.\n   *\n   * @default undefined\n   */\n  readonly backend?: BackendId;\n  /**\n   * Protocol endpoint used as the route data contract.\n   *\n   * @default undefined\n   */\n  readonly protocol?: ProtocolId;\n  /**\n   * Capabilities required by the route.\n   *\n   * @default []\n   */\n  readonly capabilities?: readonly string[];\n}\n\n/** Complete, versioned application marquette. */\nexport interface ApplicationMarquette<\n  Environments extends readonly MarquetteEnvironment[] = readonly MarquetteEnvironment[],\n  Backends extends readonly MarquetteBackend[] = readonly MarquetteBackend[],\n  Protocols extends readonly MarquetteProtocol[] = readonly MarquetteProtocol[],\n  Routes extends readonly MarquetteRoute[] = readonly MarquetteRoute[],\n> {\n  /**\n   * Serialized contract format.\n   *\n   * @default 1\n   */\n  readonly formatVersion?: typeof MARQUETTE_FORMAT_VERSION;\n  /** Stable lowercase application identifier. */\n  readonly application: string;\n  /**\n   * User-visible application targets.\n   *\n   * @default []\n   */\n  readonly targets?: readonly MarquetteTarget[];\n  /**\n   * Versioned capability definitions keyed by identifier.\n   *\n   * @default {}\n   */\n  readonly capabilities?: Readonly<Record<string, CapabilityDefinition>>;\n  /**\n   * Independently transformed application environments.\n   *\n   * @default []\n   */\n  readonly environments?: Environments;\n  /**\n   * Backend applications and services.\n   *\n   * @default []\n   */\n  readonly backends?: Backends;\n  /**\n   * Protocol endpoints.\n   *\n   * @default []\n   */\n  readonly protocols?: Protocols;\n  /**\n   * Typed routes and target views.\n   *\n   * @default []\n   */\n  readonly routes?: Routes;\n}\n\n/** Extracts identifiers only when a collection is present in the authored object. */\ntype DeclaredId<Marquette, Collection extends PropertyKey> = Marquette extends {\n  readonly [Key in Collection]: readonly { readonly id: infer Id extends string }[];\n}\n  ? Id\n  : never;\n\n/** Exact environment identifier union inferred from a marquette. */\nexport type EnvironmentId<Marquette extends ApplicationMarquette> = DeclaredId<\n  Marquette,\n  \"environments\"\n>;\n\n/** Exact server-owned environment identifier union inferred from a marquette. */\nexport type ServerEnvironmentId<Marquette extends ApplicationMarquette> = Marquette extends {\n  readonly environments: readonly (infer Environment)[];\n}\n  ? Environment extends {\n      readonly consumer: \"server\";\n      readonly id: infer Id extends string;\n    }\n    ? Id\n    : never\n  : never;\n\n/** Exact backend identifier union inferred from a marquette. */\nexport type BackendId<Marquette extends ApplicationMarquette> = DeclaredId<Marquette, \"backends\">;\n\n/** Exact protocol identifier union inferred from a marquette. */\nexport type ProtocolId<Marquette extends ApplicationMarquette> = DeclaredId<Marquette, \"protocols\">;\n\n/** Exact route identifier union inferred from a marquette. */\nexport type RouteId<Marquette extends ApplicationMarquette> = DeclaredId<Marquette, \"routes\">;\n\n/** Exact target union inferred from the authored target list. */\nexport type TargetId<Marquette extends ApplicationMarquette> = Marquette extends {\n  readonly targets: readonly (infer Target extends MarquetteTarget)[];\n}\n  ? Target\n  : never;\n\n/** Exact capability identifier union inferred from authored capability keys. */\nexport type CapabilityId<Marquette extends ApplicationMarquette> = Marquette extends {\n  readonly capabilities: Readonly<Record<infer Id extends string, CapabilityDefinition>>;\n}\n  ? Id\n  : never;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAgEA,SAAgB,2BACd,WACW;CACX,OAAO;;;;;AClET,MAAa,2BAA2B"}

package/dist/model-DWcxWbC1.d.mts

@@ -0,0 +1,197 @@
+//#region src/model.d.ts
+/** Current serialized application-marquette format. */
+declare const MARQUETTE_FORMAT_VERSION: 1;
+/** User-visible target produced by an application marquette. */
+type MarquetteTarget = "web" | "native" | "desktop" | "terminal";
+/** Runtime family that executes one environment. */
+type RuntimeFamily = "browser" | "javascript" | "rust" | "go" | "jvm" | "native" | "desktop" | "terminal" | "external";
+/** Side of the application graph that consumes an environment. */
+type EnvironmentConsumer = "client" | "server";
+/** Backend implementation family selected by an application. */
+type BackendFamily = "javascript" | "rust" | "go" | "jvm" | "external";
+/** Semantic family used by one data or procedure endpoint. */
+type ProtocolFamily = "schema-query" | "typed-rpc" | "binary-rpc";
+/** Rendering strategy selected for one route or target view. */
+type RenderingMode = "client" | "static" | "server" | "stream" | "partial" | "hybrid" | "native" | "desktop" | "terminal";
+/** Versioned capability understood by adapters and developer tools. */
+interface CapabilityDefinition {
+  /** Stable lowercase capability identifier. */
+  readonly id: string;
+  /** Summary shown by diagnostics, documentation, and AI tooling. */
+  readonly description: string;
+  /**
+   * Capability contract version.
+   *
+   * @default 1
+   */
+  readonly version?: number;
+}
+/** Independently transformed and cached application environment. */
+interface MarquetteEnvironment<Id extends string = string, DependencyId extends string = string> {
+  /** Stable identifier, unique within the application. */
+  readonly id: Id;
+  /** User-visible target served by this environment. */
+  readonly target: MarquetteTarget;
+  /** Whether output is consumed by an end user or a trusted runtime. */
+  readonly consumer: EnvironmentConsumer;
+  /** Runtime family that executes the output. */
+  readonly runtime: RuntimeFamily;
+  /**
+   * Authored entry module.
+   *
+   * @default undefined
+   */
+  readonly entry?: string;
+  /**
+   * Environments that must build first.
+   *
+   * @default []
+   */
+  readonly dependsOn?: readonly DependencyId[];
+  /**
+   * Capabilities required from the environment adapter.
+   *
+   * @default []
+   */
+  readonly capabilities?: readonly string[];
+}
+/** Backend application or independently deployed service. */
+interface MarquetteBackend<Id extends string = string, EnvironmentId extends string = string> {
+  /** Stable backend identifier. */
+  readonly id: Id;
+  /** Backend implementation family. */
+  readonly family: BackendFamily;
+  /**
+   * Server environment that owns local execution.
+   *
+   * @default undefined
+   */
+  readonly environment?: EnvironmentId;
+  /**
+   * Capabilities required from the backend adapter.
+   *
+   * @default []
+   */
+  readonly capabilities?: readonly string[];
+}
+/** Protocol endpoint exposed by a backend. */
+interface MarquetteProtocol<Id extends string = string, BackendId extends string = string> {
+  /** Stable endpoint identifier. */
+  readonly id: Id;
+  /** Protocol semantic family. */
+  readonly family: ProtocolFamily;
+  /** Backend that owns the endpoint. */
+  readonly backend: BackendId;
+  /**
+   * Capabilities required from the protocol adapter.
+   *
+   * @default []
+   */
+  readonly capabilities?: readonly string[];
+}
+/** Typed application route or target view. */
+interface MarquetteRoute<Id extends string = string, EnvironmentId extends string = string, BackendId extends string = string, ProtocolId extends string = string> {
+  /** Stable identifier used by generated navigation APIs. */
+  readonly id: Id;
+  /** Logical path, always beginning with `/`. */
+  readonly path: `/${string}`;
+  /** Environment that owns the rendered route. */
+  readonly environment: EnvironmentId;
+  /** Rendering strategy used by the route. */
+  readonly rendering: RenderingMode;
+  /**
+   * Backend used by data loading, mutations, or server rendering.
+   *
+   * @default undefined
+   */
+  readonly backend?: BackendId;
+  /**
+   * Protocol endpoint used as the route data contract.
+   *
+   * @default undefined
+   */
+  readonly protocol?: ProtocolId;
+  /**
+   * Capabilities required by the route.
+   *
+   * @default []
+   */
+  readonly capabilities?: readonly string[];
+}
+/** Complete, versioned application marquette. */
+interface ApplicationMarquette<Environments extends readonly MarquetteEnvironment[] = readonly MarquetteEnvironment[], Backends extends readonly MarquetteBackend[] = readonly MarquetteBackend[], Protocols extends readonly MarquetteProtocol[] = readonly MarquetteProtocol[], Routes extends readonly MarquetteRoute[] = readonly MarquetteRoute[]> {
+  /**
+   * Serialized contract format.
+   *
+   * @default 1
+   */
+  readonly formatVersion?: typeof MARQUETTE_FORMAT_VERSION;
+  /** Stable lowercase application identifier. */
+  readonly application: string;
+  /**
+   * User-visible application targets.
+   *
+   * @default []
+   */
+  readonly targets?: readonly MarquetteTarget[];
+  /**
+   * Versioned capability definitions keyed by identifier.
+   *
+   * @default {}
+   */
+  readonly capabilities?: Readonly<Record<string, CapabilityDefinition>>;
+  /**
+   * Independently transformed application environments.
+   *
+   * @default []
+   */
+  readonly environments?: Environments;
+  /**
+   * Backend applications and services.
+   *
+   * @default []
+   */
+  readonly backends?: Backends;
+  /**
+   * Protocol endpoints.
+   *
+   * @default []
+   */
+  readonly protocols?: Protocols;
+  /**
+   * Typed routes and target views.
+   *
+   * @default []
+   */
+  readonly routes?: Routes;
+}
+/** Extracts identifiers only when a collection is present in the authored object. */
+type DeclaredId<Marquette, Collection extends PropertyKey> = Marquette extends { readonly [Key in Collection]: readonly {
+  readonly id: infer Id extends string;
+}[] } ? Id : never;
+/** Exact environment identifier union inferred from a marquette. */
+type EnvironmentId<Marquette extends ApplicationMarquette> = DeclaredId<Marquette, "environments">;
+/** Exact server-owned environment identifier union inferred from a marquette. */
+type ServerEnvironmentId<Marquette extends ApplicationMarquette> = Marquette extends {
+  readonly environments: readonly (infer Environment)[];
+} ? Environment extends {
+  readonly consumer: "server";
+  readonly id: infer Id extends string;
+} ? Id : never : never;
+/** Exact backend identifier union inferred from a marquette. */
+type BackendId<Marquette extends ApplicationMarquette> = DeclaredId<Marquette, "backends">;
+/** Exact protocol identifier union inferred from a marquette. */
+type ProtocolId<Marquette extends ApplicationMarquette> = DeclaredId<Marquette, "protocols">;
+/** Exact route identifier union inferred from a marquette. */
+type RouteId<Marquette extends ApplicationMarquette> = DeclaredId<Marquette, "routes">;
+/** Exact target union inferred from the authored target list. */
+type TargetId<Marquette extends ApplicationMarquette> = Marquette extends {
+  readonly targets: readonly (infer Target extends MarquetteTarget)[];
+} ? Target : never;
+/** Exact capability identifier union inferred from authored capability keys. */
+type CapabilityId<Marquette extends ApplicationMarquette> = Marquette extends {
+  readonly capabilities: Readonly<Record<infer Id extends string, CapabilityDefinition>>;
+} ? Id : never;
+//#endregion
+export { RouteId as _, CapabilityId as a, TargetId as b, MARQUETTE_FORMAT_VERSION as c, MarquetteProtocol as d, MarquetteRoute as f, RenderingMode as g, ProtocolId as h, CapabilityDefinition as i, MarquetteBackend as l, ProtocolFamily as m, BackendFamily as n, EnvironmentConsumer as o, MarquetteTarget as p, BackendId as r, EnvironmentId as s, ApplicationMarquette as t, MarquetteEnvironment as u, RuntimeFamily as v, ServerEnvironmentId as y };
+//# sourceMappingURL=model-DWcxWbC1.d.mts.map

package/dist/model-DWcxWbC1.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-DWcxWbC1.d.mts","names":[],"sources":["../src/model.ts"],"mappings":";;cACa,wBAAA;;KAGD,eAAA;;KAGA,aAAA;AAHZ;AAAA,KAeY,mBAAA;;KAGA,aAAA;;KAGA,cAAA;;KAGA,aAAA;;UAYK,oBAAA;EArBL;EAAA,SAuBD,EAAA;;WAEA,WAAA;EAzBoB;AAG/B;;;;EAH+B,SA+BpB,OAAA;AAAA;;UAIM,oBAAA;EA7BS;EAAA,SAkCf,EAAA,EAAI,EAAA;EA/BH;EAAA,SAiCD,MAAA,EAAQ,eAAA;;WAER,QAAA,EAAU,mBAAA;EAnCI;EAAA,SAqCd,OAAA,EAAS,aAAA;EAzBiB;;;;;EAAA,SA+B1B,KAAA;EArBO;;AAIlB;;;EAJkB,SA2BP,SAAA,YAAqB,YAAA;EAhBb;;;;;EAAA,SAsBR,YAAA;AAAA;;UAIM,gBAAA;EA5BF;EAAA,SAiCJ,EAAA,EAAI,EAAA;EA/BI;EAAA,SAiCR,MAAA,EAAQ,aAAA;EA/BE;;;;;EAAA,SAqCV,WAAA,GAAc,aAAA;EAjBd;;;AAIX;;EAJW,SAuBA,YAAA;AAAA;;UAIM,iBAAA;EAVqB;EAAA,SAY3B,EAAA,EAAI,EAAA;EAxBb;EAAA,SA0BS,MAAA,EAAQ,cAAA;EAtBR;EAAA,SAwBA,OAAA,EAAS,SAAA;EAtBT;;;;;EAAA,SA4BA,YAAA;AAAA;AAZX;AAAA,UAgBiB,cAAA;EAhBiB;EAAA,SAuBvB,EAAA,EAAI,EAAA;EAnBI;EAAA,SAqBR,IAAA;EAnBkB;EAAA,SAqBlB,WAAA,EAAa,aAAA;EA3BW;EAAA,SA6BxB,SAAA,EAAW,aAAA;EA3BX;;;;;EAAA,SAiCA,OAAA,GAAU,SAAA;EAvBV;;;AAIX;;EAJW,SA6BA,QAAA,GAAW,UAAA;EAlBP;;;;;EAAA,SAwBJ,YAAA;AAAA;;UAIM,oBAAA,+BACe,oBAAA,cAAkC,oBAAA,8BACtC,gBAAA,cAA8B,gBAAA,+BAC7B,iBAAA,cAA+B,iBAAA,4BAClC,cAAA,cAA4B,cAAA;EApCpD;;;;;EAAA,SA2CS,aAAA,UAAuB,wBAAA;EAnCV;EAAA,SAqCb,WAAA;EAnCW;;;;;EAAA,SAyCX,OAAA,YAAmB,eAAA;EAvBP;;AAIvB;;;EAJuB,SA6BZ,YAAA,GAAe,QAAA,CAAS,MAAA,SAAe,oBAAA;EAxBgB;;;;;EAAA,SA8BvD,YAAA,GAAe,YAAA;EA3B4B;;;;;EAAA,SAiC3C,QAAA,GAAW,QAAA;EANI;;;;;EAAA,SAYf,SAAA,GAAY,SAAA;EA1CrB;;;;;EAAA,SAgDS,MAAA,GAAS,MAAA;AAAA;;KAIf,UAAA,+BAAyC,WAAA,IAAe,SAAA,4BAC1C,UAAA;EAAA,SAAiC,EAAA;AAAA,QAEhD,EAAA;;KAIQ,aAAA,mBAAgC,oBAAA,IAAwB,UAAA,CAClE,SAAA;;KAKU,mBAAA,mBAAsC,oBAAA,IAAwB,SAAA;EAAA,SAC/D,YAAA;AAAA,IAEP,WAAA;EAAA,SACW,QAAA;EAAA,SACA,EAAA;AAAA,IAET,EAAA;;KAKM,SAAA,mBAA4B,oBAAA,IAAwB,UAAA,CAAW,SAAA;;KAG/D,UAAA,mBAA6B,oBAAA,IAAwB,UAAA,CAAW,SAAA;;KAGhE,OAAA,mBAA0B,oBAAA,IAAwB,UAAA,CAAW,SAAA;;KAG7D,QAAA,mBAA2B,oBAAA,IAAwB,SAAA;EAAA,SACpD,OAAA,iCAAwC,eAAA;AAAA,IAE/C,MAAA;;KAIQ,YAAA,mBAA+B,oBAAA,IAAwB,SAAA;EAAA,SACxD,YAAA,EAAc,QAAA,CAAS,MAAA,0BAAgC,oBAAA;AAAA,IAE9D,EAAA"}

package/dist/test-run-admission.d.mts

@@ -0,0 +1,48 @@
+import { i as TestRunEvidence } from "./test-run-model-DkllmEsY.mjs";
+import { MarquetteDiagnostic } from "./validate.mjs";
+import { TEST_RUN_ADMISSION_PREFIX, parseTestRunAdmissionId } from "./test-run-canonical.mjs";
+
+//#region src/test-run-admission.d.ts
+/**
+ * Exact release candidate a deployment gate wants evidence for.
+ *
+ * Every field must match the record exactly; admission never falls back to a
+ * newer, older, or partially matching record.
+ */
+interface TestRunCandidate {
+  /** Application the gate is deploying. */
+  readonly application: string;
+  /** Deployment environment the gate is promoting into. */
+  readonly environment: string;
+  /** Lowercase SHA-256 fingerprint of the application contract. */
+  readonly contractFingerprint: string;
+  /** Exact source revision of the candidate. */
+  readonly sourceRevision: string;
+  /** Release the candidate belongs to. */
+  readonly release: string;
+  /** Lowercase SHA-256 fingerprint of the exact artifact being promoted. */
+  readonly artifactFingerprint: string;
+}
+/**
+ * Decides whether one record admits one exact candidate at one instant.
+ *
+ * An empty result admits the deployment. Any diagnostic rejects it: the
+ * record must validate cleanly, its canonical fingerprint must be the one
+ * named by `admissionId`, every candidate binding must match exactly, the
+ * record must not be expired at `now`, the independent verification must
+ * have accepted the run, and no skipped test may remain unaccounted for.
+ *
+ * Codes, paths, messages, and ordering are identical to the native
+ * implementation, so both host families reach the same decision for the
+ * same record.
+ *
+ * `now` must be a millisecond-precision UTC timestamp such as
+ * `2026-01-01T00:00:00.000Z`; the fixed-width format keeps the expiry
+ * comparison exact. Callers own retrieval: fetch the canonical bytes from an
+ * immutable store within their own deadline, refuse oversized content, and
+ * hand the parsed record here.
+ */
+declare function admitTestRun(evidence: TestRunEvidence, candidate: TestRunCandidate, admissionId: string, now: string): Promise<MarquetteDiagnostic[]>;
+//#endregion
+export { TEST_RUN_ADMISSION_PREFIX, TestRunCandidate, admitTestRun, parseTestRunAdmissionId };
+//# sourceMappingURL=test-run-admission.d.mts.map

package/dist/test-run-admission.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-run-admission.d.mts","names":[],"sources":["../src/test-run-admission.ts"],"mappings":";;;;;;;AAcA;;;;UAAiB,gBAAA;EAIN;EAAA,SAFA,WAAA;EAMA;EAAA,SAJA,WAAA;EAQA;EAAA,SANA,mBAAA;EAMmB;EAAA,SAJnB,cAAA;EA0BuB;EAAA,SAxBvB,OAAA;EAyBC;EAAA,SAvBD,mBAAA;AAAA;;;;;;;;;;;;;;;;;;;;iBAsBW,YAAA,CACpB,QAAA,EAAU,eAAA,EACV,SAAA,EAAW,gBAAA,EACX,WAAA,UACA,GAAA,WACC,OAAA,CAAQ,mBAAA"}

package/dist/test-run-admission.mjs

@@ -0,0 +1,72 @@
+import { a as error, o as isStrictTimestamp, t as validateTestRunEvidence } from "./test-run-validate-XF0vyoWI.mjs";
+import { TEST_RUN_ADMISSION_PREFIX, parseTestRunAdmissionId, testRunFingerprint } from "./test-run-canonical.mjs";
+//#region src/test-run-admission.ts
+/**
+* Decides whether one record admits one exact candidate at one instant.
+*
+* An empty result admits the deployment. Any diagnostic rejects it: the
+* record must validate cleanly, its canonical fingerprint must be the one
+* named by `admissionId`, every candidate binding must match exactly, the
+* record must not be expired at `now`, the independent verification must
+* have accepted the run, and no skipped test may remain unaccounted for.
+*
+* Codes, paths, messages, and ordering are identical to the native
+* implementation, so both host families reach the same decision for the
+* same record.
+*
+* `now` must be a millisecond-precision UTC timestamp such as
+* `2026-01-01T00:00:00.000Z`; the fixed-width format keeps the expiry
+* comparison exact. Callers own retrieval: fetch the canonical bytes from an
+* immutable store within their own deadline, refuse oversized content, and
+* hand the parsed record here.
+*/
+async function admitTestRun(evidence, candidate, admissionId, now) {
+	const diagnostics = validateTestRunEvidence(evidence);
+	const nowIsExact = isStrictTimestamp(now);
+	if (!nowIsExact) diagnostics.push(error("VIZE_MARQUETTE_148", "admission.now", "admission time must be a millisecond-precision UTC instant"));
+	const expected = parseTestRunAdmissionId(admissionId);
+	if (expected === void 0) diagnostics.push(error("VIZE_MARQUETTE_141", "admission.id", "admission id must be test-run: followed by 64 lowercase hexadecimal characters"));
+	else if (await testRunFingerprint(evidence) !== expected) diagnostics.push(error("VIZE_MARQUETTE_142", "admission.id", "admission id does not name this record's canonical fingerprint"));
+	const bindings = [
+		[
+			evidence.application,
+			candidate.application,
+			"application"
+		],
+		[
+			evidence.environment,
+			candidate.environment,
+			"environment"
+		],
+		[
+			evidence.contractFingerprint,
+			candidate.contractFingerprint,
+			"contractFingerprint"
+		],
+		[
+			evidence.sourceRevision,
+			candidate.sourceRevision,
+			"sourceRevision"
+		],
+		[
+			evidence.release,
+			candidate.release,
+			"release"
+		],
+		[
+			evidence.artifact.fingerprint,
+			candidate.artifactFingerprint,
+			"artifact.fingerprint"
+		]
+	];
+	for (const [recorded, wanted, field] of bindings) if (recorded !== wanted) diagnostics.push(error("VIZE_MARQUETTE_144", field, `record does not bind the candidate ${field}`));
+	if (nowIsExact && evidence.validUntil <= now) diagnostics.push(error("VIZE_MARQUETTE_145", "validUntil", "record is expired at the admission time"));
+	if (evidence.verification.outcome !== "accepted") diagnostics.push(error("VIZE_MARQUETTE_146", "verification.outcome", "only an accepted verification can admit a deployment"));
+	if (evidence.verification.skipped > 0) diagnostics.push(error("VIZE_MARQUETTE_147", "verification.skipped", "skipped tests are not approved for deployment admission"));
+	diagnostics.sort((left, right) => left.path !== right.path ? left.path < right.path ? -1 : 1 : left.code !== right.code ? left.code < right.code ? -1 : 1 : left.message < right.message ? -1 : left.message > right.message ? 1 : 0);
+	return diagnostics;
+}
+//#endregion
+export { TEST_RUN_ADMISSION_PREFIX, admitTestRun, parseTestRunAdmissionId };
+
+//# sourceMappingURL=test-run-admission.mjs.map

package/dist/test-run-admission.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-run-admission.mjs","names":[],"sources":["../src/test-run-admission.ts"],"sourcesContent":["import type { TestRunEvidence } from \"./test-run-model.js\";\nimport type { MarquetteDiagnostic } from \"./validate.js\";\nimport { parseTestRunAdmissionId, testRunFingerprint } from \"./test-run-canonical.js\";\nimport { validateTestRunEvidence } from \"./test-run-validate.js\";\nimport { error, isStrictTimestamp } from \"./test-run-validate-rules.js\";\n\nexport { TEST_RUN_ADMISSION_PREFIX, parseTestRunAdmissionId } from \"./test-run-canonical.js\";\n\n/**\n * Exact release candidate a deployment gate wants evidence for.\n *\n * Every field must match the record exactly; admission never falls back to a\n * newer, older, or partially matching record.\n */\nexport interface TestRunCandidate {\n  /** Application the gate is deploying. */\n  readonly application: string;\n  /** Deployment environment the gate is promoting into. */\n  readonly environment: string;\n  /** Lowercase SHA-256 fingerprint of the application contract. */\n  readonly contractFingerprint: string;\n  /** Exact source revision of the candidate. */\n  readonly sourceRevision: string;\n  /** Release the candidate belongs to. */\n  readonly release: string;\n  /** Lowercase SHA-256 fingerprint of the exact artifact being promoted. */\n  readonly artifactFingerprint: string;\n}\n\n/**\n * Decides whether one record admits one exact candidate at one instant.\n *\n * An empty result admits the deployment. Any diagnostic rejects it: the\n * record must validate cleanly, its canonical fingerprint must be the one\n * named by `admissionId`, every candidate binding must match exactly, the\n * record must not be expired at `now`, the independent verification must\n * have accepted the run, and no skipped test may remain unaccounted for.\n *\n * Codes, paths, messages, and ordering are identical to the native\n * implementation, so both host families reach the same decision for the\n * same record.\n *\n * `now` must be a millisecond-precision UTC timestamp such as\n * `2026-01-01T00:00:00.000Z`; the fixed-width format keeps the expiry\n * comparison exact. Callers own retrieval: fetch the canonical bytes from an\n * immutable store within their own deadline, refuse oversized content, and\n * hand the parsed record here.\n */\nexport async function admitTestRun(\n  evidence: TestRunEvidence,\n  candidate: TestRunCandidate,\n  admissionId: string,\n  now: string,\n): Promise<MarquetteDiagnostic[]> {\n  const diagnostics = validateTestRunEvidence(evidence);\n\n  const nowIsExact = isStrictTimestamp(now);\n  if (!nowIsExact) {\n    diagnostics.push(\n      error(\n        \"VIZE_MARQUETTE_148\",\n        \"admission.now\",\n        \"admission time must be a millisecond-precision UTC instant\",\n      ),\n    );\n  }\n\n  const expected = parseTestRunAdmissionId(admissionId);\n  if (expected === undefined) {\n    diagnostics.push(\n      error(\n        \"VIZE_MARQUETTE_141\",\n        \"admission.id\",\n        \"admission id must be test-run: followed by 64 lowercase hexadecimal characters\",\n      ),\n    );\n  } else if ((await testRunFingerprint(evidence)) !== expected) {\n    diagnostics.push(\n      error(\n        \"VIZE_MARQUETTE_142\",\n        \"admission.id\",\n        \"admission id does not name this record's canonical fingerprint\",\n      ),\n    );\n  }\n\n  const bindings = [\n    [evidence.application, candidate.application, \"application\"],\n    [evidence.environment, candidate.environment, \"environment\"],\n    [evidence.contractFingerprint, candidate.contractFingerprint, \"contractFingerprint\"],\n    [evidence.sourceRevision, candidate.sourceRevision, \"sourceRevision\"],\n    [evidence.release, candidate.release, \"release\"],\n    [evidence.artifact.fingerprint, candidate.artifactFingerprint, \"artifact.fingerprint\"],\n  ] as const;\n  for (const [recorded, wanted, field] of bindings) {\n    if (recorded !== wanted) {\n      diagnostics.push(\n        error(\"VIZE_MARQUETTE_144\", field, `record does not bind the candidate ${field}`),\n      );\n    }\n  }\n\n  if (nowIsExact && evidence.validUntil <= now) {\n    diagnostics.push(\n      error(\"VIZE_MARQUETTE_145\", \"validUntil\", \"record is expired at the admission time\"),\n    );\n  }\n  if (evidence.verification.outcome !== \"accepted\") {\n    diagnostics.push(\n      error(\n        \"VIZE_MARQUETTE_146\",\n        \"verification.outcome\",\n        \"only an accepted verification can admit a deployment\",\n      ),\n    );\n  }\n  if (evidence.verification.skipped > 0) {\n    diagnostics.push(\n      error(\n        \"VIZE_MARQUETTE_147\",\n        \"verification.skipped\",\n        \"skipped tests are not approved for deployment admission\",\n      ),\n    );\n  }\n\n  diagnostics.sort((left, right) =>\n    left.path !== right.path\n      ? left.path < right.path\n        ? -1\n        : 1\n      : left.code !== right.code\n        ? left.code < right.code\n          ? -1\n          : 1\n        : left.message < right.message\n          ? -1\n          : left.message > right.message\n            ? 1\n            : 0,\n  );\n  return diagnostics;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAgDA,eAAsB,aACpB,UACA,WACA,aACA,KACgC;CAChC,MAAM,cAAc,wBAAwB,SAAS;CAErD,MAAM,aAAa,kBAAkB,IAAI;CACzC,IAAI,CAAC,YACH,YAAY,KACV,MACE,sBACA,iBACA,6DACD,CACF;CAGH,MAAM,WAAW,wBAAwB,YAAY;CACrD,IAAI,aAAa,KAAA,GACf,YAAY,KACV,MACE,sBACA,gBACA,iFACD,CACF;MACI,IAAK,MAAM,mBAAmB,SAAS,KAAM,UAClD,YAAY,KACV,MACE,sBACA,gBACA,iEACD,CACF;CAGH,MAAM,WAAW;EACf;GAAC,SAAS;GAAa,UAAU;GAAa;GAAc;EAC5D;GAAC,SAAS;GAAa,UAAU;GAAa;GAAc;EAC5D;GAAC,SAAS;GAAqB,UAAU;GAAqB;GAAsB;EACpF;GAAC,SAAS;GAAgB,UAAU;GAAgB;GAAiB;EACrE;GAAC,SAAS;GAAS,UAAU;GAAS;GAAU;EAChD;GAAC,SAAS,SAAS;GAAa,UAAU;GAAqB;GAAuB;EACvF;CACD,KAAK,MAAM,CAAC,UAAU,QAAQ,UAAU,UACtC,IAAI,aAAa,QACf,YAAY,KACV,MAAM,sBAAsB,OAAO,sCAAsC,QAAQ,CAClF;CAIL,IAAI,cAAc,SAAS,cAAc,KACvC,YAAY,KACV,MAAM,sBAAsB,cAAc,0CAA0C,CACrF;CAEH,IAAI,SAAS,aAAa,YAAY,YACpC,YAAY,KACV,MACE,sBACA,wBACA,uDACD,CACF;CAEH,IAAI,SAAS,aAAa,UAAU,GAClC,YAAY,KACV,MACE,sBACA,wBACA,0DACD,CACF;CAGH,YAAY,MAAM,MAAM,UACtB,KAAK,SAAS,MAAM,OAChB,KAAK,OAAO,MAAM,OAChB,KACA,IACF,KAAK,SAAS,MAAM,OAClB,KAAK,OAAO,MAAM,OAChB,KACA,IACF,KAAK,UAAU,MAAM,UACnB,KACA,KAAK,UAAU,MAAM,UACnB,IACA,EACX;CACD,OAAO"}

package/dist/test-run-canonical.d.mts

@@ -0,0 +1,35 @@
+import { i as TestRunEvidence } from "./test-run-model-DkllmEsY.mjs";
+
+//#region src/test-run-canonical.d.ts
+/** Prefix of every test-run deployment admission id. */
+declare const TEST_RUN_ADMISSION_PREFIX = "test-run:";
+/**
+ * Serializes a test-run evidence record canonically.
+ *
+ * Property order matches the record schema, targets sort by id, suites sort
+ * by id then shard index, and selection identifiers sort lexicographically,
+ * so equivalent records produce byte-identical JSON in every language. Call
+ * validation before trusting the record; canonicalization does not make an
+ * invalid record valid.
+ */
+declare function canonicalTestRunJson(evidence: TestRunEvidence): string;
+/**
+ * Returns the lowercase SHA-256 fingerprint of the canonical record.
+ *
+ * The fingerprint is the exact value admitted as `test-run:<sha256>` by
+ * deployment gates. Uses the Web Crypto API available in every supported
+ * runtime.
+ */
+declare function testRunFingerprint(evidence: TestRunEvidence): Promise<string>;
+/** Returns the `test-run:<sha256>` admission id for one record. */
+declare function testRunAdmissionId(evidence: TestRunEvidence): Promise<string>;
+/**
+ * Returns the fingerprint named by a `test-run:<sha256>` admission id.
+ *
+ * Returns `undefined` unless the prefix, length, and lowercase hexadecimal
+ * grammar are all exact.
+ */
+declare function parseTestRunAdmissionId(id: string): string | undefined;
+//#endregion
+export { TEST_RUN_ADMISSION_PREFIX, canonicalTestRunJson, parseTestRunAdmissionId, testRunAdmissionId, testRunFingerprint };
+//# sourceMappingURL=test-run-canonical.d.mts.map

package/dist/test-run-canonical.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-run-canonical.d.mts","names":[],"sources":["../src/test-run-canonical.ts"],"mappings":";;;;cAQa,yBAAA;AAAb;;;;;AAwCA;;;;AAxCA,iBAwCgB,oBAAA,CAAqB,QAAA,EAAU,eAAA;AA6D/C;;;;;;;AAAA,iBAAsB,kBAAA,CAAmB,QAAA,EAAU,eAAA,GAAkB,OAAA;;iBAW/C,kBAAA,CAAmB,QAAA,EAAU,eAAA,GAAkB,OAAA;;;;;;;iBAUrD,uBAAA,CAAwB,EAAA"}