every-plugin 3.0.0-rc.15 → 3.0.0-rc.17

package/dist/version-manifest.cjs

@@ -12,10 +12,35 @@ let node_crypto = require("node:crypto");
 * stops growing with artifact kinds and old versions stay fully servable.
 */
 const SRI = zod.z.string().regex(/^sha384-[A-Za-z0-9+/=]+$/);
+/** Slot-relative directory holding one deploy's immutable file copies (#826). */
+const VERSION_DIR_PATTERN = /^versions\/[0-9a-f]{16}$/;
+/** The attribution block stored in the manifest's `signature` field. The
+* verifying key rides along so a verifier can distinguish "wrong signature"
+* from "signed by a key the config never registered" — both are
+* `SignatureInvalid`, but the reasons name different compromises. */
+const ManifestSignatureSchema = zod.z.object({
+	algorithm: zod.z.literal("ed25519"),
+	/** NEAR-format verifying key (`ed25519:<base58>`) — must equal the
+	* config's `publish.verification.publicKey`. */
+	publicKey: zod.z.string().min(1),
+	/** base64 ed25519 signature over the canonical payload bytes. */
+	value: zod.z.string().min(1)
+});
 const WorkspaceVersionManifestSchema = zod.z.object({
 	version: zod.z.string().regex(/^[0-9a-f]{16}$/),
 	builtAt: zod.z.string().optional(),
 	gitSha: zod.z.string().optional(),
+	/**
+	* Slot-relative directory (`versions/<dirId>`) holding this deploy's
+	* byte-immutable copies of every dist file (#826). When present, all
+	* artifact coordinates below resolve against `<slotBase>/<dir>/` — so a
+	* pinned child's entry fetches its expose chunk and chunks from the same
+	* frozen directory instead of the mutable slot root. Absent on legacy
+	* manifests: coordinates resolve against the slot root exactly as before.
+	* Derived from the `files` map (see `versionDirPath`), so it participates
+	* in the version hash without circularity.
+	*/
+	dir: zod.z.string().regex(VERSION_DIR_PATTERN).optional(),
 	entry: zod.z.string().min(1),
 	entryIntegrity: SRI,
 	ssr: zod.z.object({
@@ -48,8 +73,38 @@ const WorkspaceVersionManifestSchema = zod.z.object({
 	source: zod.z.object({
 		file: zod.z.string().min(1),
 		integrity: SRI
-	}).optional()
+	}).optional(),
+	/**
+	* Attribution (ADR 0046 ticket 05): the deploy train's ed25519 signature
+	* over `signaturePayloadOf(this document)` — SRI attests WHAT the bytes
+	* are, the signature attests WHO published them, with the verifying key
+	* anchored in the on-chain config (`publish.verification`). Absent on
+	* rollouts with attribution off; readers that predate the field ignore it
+	* (zod strips unknown keys). Excluded from the version-id derivation —
+	* like `builtAt`, it is not a coordinate of the build.
+	*/
+	signature: ManifestSignatureSchema.optional()
 });
+/** Canonical key-sorted JSON serialization — the same form the version-id
+* derivation hashes (undefined-valued entries dropped). Exported so the
+* signature payload and the version id can never disagree about what
+* "canonical" means. */
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.entries(value).filter(([, v]) => v !== void 0).map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).sort().join(",")}}`;
+	return JSON.stringify(value) ?? "null";
+}
+/**
+* The bytes a manifest signature attests: the document minus its reserved
+* `signature` field, canonically serialized (key-sorted — the version-id
+* rule). The signer signs this before the field exists; the verifier
+* re-derives it from the parsed document, so the stored document's
+* whitespace never matters.
+*/
+function signaturePayloadOf(manifest) {
+	const { signature: _signature, ...payload } = manifest;
+	return stableStringify(payload);
+}
 /**
 * Compose the manifest with its `version` derived from the canonical content
 * of the artifact coordinates alone (key-sorted, `builtAt` excluded) —
@@ -65,13 +120,23 @@ function composeVersionManifest(input) {
 		version
 	});
 }
-function stableStringify(value) {
-	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
-	if (value && typeof value === "object") return `{${Object.entries(value).filter(([, v]) => v !== void 0).map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).sort().join(",")}}`;
-	return JSON.stringify(value) ?? "null";
+/**
+* The content-addressed directory name for one dist's file set (#826): a
+* 16-hex hash over the canonical files map. Identical bytes → identical
+* directory → re-deploying unchanged content is a server-side no-op, and a
+* published pin's directory can never be rewritten by a later deploy
+* (the upload service refuses conflicting writes under `versions/`).
+*/
+function versionDirPath(files) {
+	return `versions/${(0, node_crypto.createHash)("sha256").update(stableStringify(files)).digest("hex").slice(0, 16)}`;
 }
 
 //#endregion
+exports.ManifestSignatureSchema = ManifestSignatureSchema;
+exports.VERSION_DIR_PATTERN = VERSION_DIR_PATTERN;
 exports.WorkspaceVersionManifestSchema = WorkspaceVersionManifestSchema;
 exports.composeVersionManifest = composeVersionManifest;
+exports.signaturePayloadOf = signaturePayloadOf;
+exports.stableStringify = stableStringify;
+exports.versionDirPath = versionDirPath;
 //# sourceMappingURL=version-manifest.cjs.map

package/dist/version-manifest.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"version-manifest.cjs","names":["z","createHash"],"sources":["../src/version-manifest.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { z } from \"zod\";\n\n/**\n * WorkspaceVersionManifest — the immutable per-deploy document at\n * `bundles/<account>/<gateway>/<workspace>/versions/<version>.json`\n * (ADR 0020, as amended; atomic-deploys MAP decision 1). The published\n * config's slot pins this document via its `pin` (`manifest` + the\n * manifest's own SRI); every artifact coordinate lives here, so the config\n * stops growing with artifact kinds and old versions stay fully servable.\n */\n\nconst SRI = z.string().regex(/^sha384-[A-Za-z0-9+/=]+$/);\n\nexport const WorkspaceVersionManifestSchema = z.object({\n  version: z.string().regex(/^[0-9a-f]{16}$/),\n  builtAt: z.string().optional(),\n  gitSha: z.string().optional(),\n  entry: z.string().min(1),\n  entryIntegrity: SRI,\n  ssr: z\n    .object({\n      entry: z.string().min(1),\n      integrity: SRI,\n    })\n    .optional(),\n  browserManifest: z\n    .object({\n      file: z.string().min(1),\n      integrity: SRI,\n    })\n    .optional(),\n  /** extra assets (css, icons) — logical name → served-object SRI */\n  assets: z.record(z.string(), SRI).optional(),\n  /** shared-dependency versions this build was built against */\n  shared: z.record(z.string(), z.string()).optional(),\n  /**\n   * Full per-file digest map of the dist (object path → served-object SRI).\n   * Written by `every-plugin`-based deploys so the next deploy can diff against\n   * it and skip re-uploading unchanged files; readers that predate the field\n   * ignore it (zod strips unknown keys). Participates in the version hash.\n   */\n  files: z.record(z.string(), SRI).optional(),\n  /**\n   * Source archive of the workspace subtree (object path → served-object SRI)\n   * published beside the dists when the runtime opts in via\n   * `publish.sourcePublish` — lets `bos import` dereference a published\n   * config slot to the exact source bytes that build came from, with no\n   * GitHub dependency. Readers that predate the field ignore it (zod strips\n   * unknown keys). Participates in the version hash.\n   */\n  source: z\n    .object({\n      file: z.string().min(1),\n      integrity: SRI,\n    })\n    .optional(),\n});\nexport type WorkspaceVersionManifest = z.infer<typeof WorkspaceVersionManifestSchema>;\n\n/** A published-artifact coordinate: object path within the bundle namespace + its served SRI. */\nexport type SourceRef = NonNullable<WorkspaceVersionManifest[\"source\"]>;\n\nexport interface VersionManifestInput {\n  /** Omit: a per-build timestamp makes the same version id map to different\n   * manifest bytes per machine, breaking the pin's SRI against the image's\n   * staged copy and the CDN's immutability for republished versions. */\n  builtAt?: string;\n  gitSha?: string;\n  entry: string;\n  entryIntegrity: string;\n  ssr?: { entry: string; integrity: string };\n  browserManifest?: { file: string; integrity: string };\n  assets?: Record<string, string>;\n  shared?: Record<string, string>;\n  files?: Record<string, string>;\n  source?: { file: string; integrity: string };\n}\n\n/**\n * Compose the manifest with its `version` derived from the canonical content\n * of the artifact coordinates alone (key-sorted, `builtAt` excluded) —\n * identical bytes → identical version id regardless of when they were built,\n * so republishing unchanged content is a pointer no-op. Any changed\n * coordinate → a new version (and a new file).\n */\nexport function composeVersionManifest(input: VersionManifestInput): WorkspaceVersionManifest {\n  const { builtAt: _builtAt, ...hashedInputs } = input;\n  const version = createHash(\"sha256\")\n    .update(stableStringify(hashedInputs))\n    .digest(\"hex\")\n    .slice(0, 16);\n  return WorkspaceVersionManifestSchema.parse({ ...input, version });\n}\n\nfunction stableStringify(value: unknown): string {\n  if (Array.isArray(value)) return `[${value.map(stableStringify).join(\",\")}]`;\n  if (value && typeof value === \"object\") {\n    return `{${Object.entries(value)\n      .filter(([, v]) => v !== undefined)\n      .map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`)\n      .sort()\n      .join(\",\")}}`;\n  }\n  return JSON.stringify(value) ?? \"null\";\n}\n"],"mappings":";;;;;;;;;;;;;AAYA,MAAM,MAAMA,MAAE,OAAO,CAAC,CAAC,MAAM,0BAA0B;AAEvD,MAAa,iCAAiCA,MAAE,OAAO;CACrD,SAASA,MAAE,OAAO,CAAC,CAAC,MAAM,gBAAgB;CAC1C,SAASA,MAAE,OAAO,CAAC,CAAC,SAAS;CAC7B,QAAQA,MAAE,OAAO,CAAC,CAAC,SAAS;CAC5B,OAAOA,MAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CACvB,gBAAgB;CAChB,KAAKA,MACF,OAAO;EACN,OAAOA,MAAE,OAAO,CAAC,CAAC,IAAI,CAAC;EACvB,WAAW;CACb,CAAC,CAAC,CACD,SAAS;CACZ,iBAAiBA,MACd,OAAO;EACN,MAAMA,MAAE,OAAO,CAAC,CAAC,IAAI,CAAC;EACtB,WAAW;CACb,CAAC,CAAC,CACD,SAAS;;CAEZ,QAAQA,MAAE,OAAOA,MAAE,OAAO,GAAG,GAAG,CAAC,CAAC,SAAS;;CAE3C,QAAQA,MAAE,OAAOA,MAAE,OAAO,GAAGA,MAAE,OAAO,CAAC,CAAC,CAAC,SAAS;;;;;;;CAOlD,OAAOA,MAAE,OAAOA,MAAE,OAAO,GAAG,GAAG,CAAC,CAAC,SAAS;;;;;;;;;CAS1C,QAAQA,MACL,OAAO;EACN,MAAMA,MAAE,OAAO,CAAC,CAAC,IAAI,CAAC;EACtB,WAAW;CACb,CAAC,CAAC,CACD,SAAS;AACd,CAAC;;;;;;;;AA6BD,SAAgB,uBAAuB,OAAuD;CAC5F,MAAM,EAAE,SAAS,UAAU,GAAG,iBAAiB;CAC/C,MAAM,cAAUC,wBAAW,QAAQ,CAAC,CACjC,OAAO,gBAAgB,YAAY,CAAC,CAAC,CACrC,OAAO,KAAK,CAAC,CACb,MAAM,GAAG,EAAE;CACd,OAAO,+BAA+B,MAAM;EAAE,GAAG;EAAO;CAAQ,CAAC;AACnE;AAEA,SAAS,gBAAgB,OAAwB;CAC/C,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO,IAAI,MAAM,IAAI,eAAe,CAAC,CAAC,KAAK,GAAG,EAAE;CAC1E,IAAI,SAAS,OAAO,UAAU,UAC5B,OAAO,IAAI,OAAO,QAAQ,KAAK,CAAC,CAC7B,QAAQ,GAAG,OAAO,MAAM,MAAS,CAAC,CAClC,KAAK,CAAC,GAAG,OAAO,GAAG,KAAK,UAAU,CAAC,EAAE,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAC7D,KAAK,CAAC,CACN,KAAK,GAAG,EAAE;CAEf,OAAO,KAAK,UAAU,KAAK,KAAK;AAClC"}
+{"version":3,"file":"version-manifest.cjs","names":["z","createHash"],"sources":["../src/version-manifest.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { z } from \"zod\";\n\n/**\n * WorkspaceVersionManifest — the immutable per-deploy document at\n * `bundles/<account>/<gateway>/<workspace>/versions/<version>.json`\n * (ADR 0020, as amended; atomic-deploys MAP decision 1). The published\n * config's slot pins this document via its `pin` (`manifest` + the\n * manifest's own SRI); every artifact coordinate lives here, so the config\n * stops growing with artifact kinds and old versions stay fully servable.\n */\n\nconst SRI = z.string().regex(/^sha384-[A-Za-z0-9+/=]+$/);\n\n/** Slot-relative directory holding one deploy's immutable file copies (#826). */\nexport const VERSION_DIR_PATTERN = /^versions\\/[0-9a-f]{16}$/;\n\n/** The attribution block stored in the manifest's `signature` field. The\n * verifying key rides along so a verifier can distinguish \"wrong signature\"\n * from \"signed by a key the config never registered\" — both are\n * `SignatureInvalid`, but the reasons name different compromises. */\nexport const ManifestSignatureSchema = z.object({\n  algorithm: z.literal(\"ed25519\"),\n  /** NEAR-format verifying key (`ed25519:<base58>`) — must equal the\n   * config's `publish.verification.publicKey`. */\n  publicKey: z.string().min(1),\n  /** base64 ed25519 signature over the canonical payload bytes. */\n  value: z.string().min(1),\n});\nexport type ManifestSignature = z.infer<typeof ManifestSignatureSchema>;\n\nexport const WorkspaceVersionManifestSchema = z.object({\n  version: z.string().regex(/^[0-9a-f]{16}$/),\n  builtAt: z.string().optional(),\n  gitSha: z.string().optional(),\n  /**\n   * Slot-relative directory (`versions/<dirId>`) holding this deploy's\n   * byte-immutable copies of every dist file (#826). When present, all\n   * artifact coordinates below resolve against `<slotBase>/<dir>/` — so a\n   * pinned child's entry fetches its expose chunk and chunks from the same\n   * frozen directory instead of the mutable slot root. Absent on legacy\n   * manifests: coordinates resolve against the slot root exactly as before.\n   * Derived from the `files` map (see `versionDirPath`), so it participates\n   * in the version hash without circularity.\n   */\n  dir: z.string().regex(VERSION_DIR_PATTERN).optional(),\n  entry: z.string().min(1),\n  entryIntegrity: SRI,\n  ssr: z\n    .object({\n      entry: z.string().min(1),\n      integrity: SRI,\n    })\n    .optional(),\n  browserManifest: z\n    .object({\n      file: z.string().min(1),\n      integrity: SRI,\n    })\n    .optional(),\n  /** extra assets (css, icons) — logical name → served-object SRI */\n  assets: z.record(z.string(), SRI).optional(),\n  /** shared-dependency versions this build was built against */\n  shared: z.record(z.string(), z.string()).optional(),\n  /**\n   * Full per-file digest map of the dist (object path → served-object SRI).\n   * Written by `every-plugin`-based deploys so the next deploy can diff against\n   * it and skip re-uploading unchanged files; readers that predate the field\n   * ignore it (zod strips unknown keys). Participates in the version hash.\n   */\n  files: z.record(z.string(), SRI).optional(),\n  /**\n   * Source archive of the workspace subtree (object path → served-object SRI)\n   * published beside the dists when the runtime opts in via\n   * `publish.sourcePublish` — lets `bos import` dereference a published\n   * config slot to the exact source bytes that build came from, with no\n   * GitHub dependency. Readers that predate the field ignore it (zod strips\n   * unknown keys). Participates in the version hash.\n   */\n  source: z\n    .object({\n      file: z.string().min(1),\n      integrity: SRI,\n    })\n    .optional(),\n  /**\n   * Attribution (ADR 0046 ticket 05): the deploy train's ed25519 signature\n   * over `signaturePayloadOf(this document)` — SRI attests WHAT the bytes\n   * are, the signature attests WHO published them, with the verifying key\n   * anchored in the on-chain config (`publish.verification`). Absent on\n   * rollouts with attribution off; readers that predate the field ignore it\n   * (zod strips unknown keys). Excluded from the version-id derivation —\n   * like `builtAt`, it is not a coordinate of the build.\n   */\n  signature: ManifestSignatureSchema.optional(),\n});\nexport type WorkspaceVersionManifest = z.infer<typeof WorkspaceVersionManifestSchema>;\n\n/** Canonical key-sorted JSON serialization — the same form the version-id\n * derivation hashes (undefined-valued entries dropped). Exported so the\n * signature payload and the version id can never disagree about what\n * \"canonical\" means. */\nexport function stableStringify(value: unknown): string {\n  if (Array.isArray(value)) return `[${value.map(stableStringify).join(\",\")}]`;\n  if (value && typeof value === \"object\") {\n    return `{${Object.entries(value)\n      .filter(([, v]) => v !== undefined)\n      .map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`)\n      .sort()\n      .join(\",\")}}`;\n  }\n  return JSON.stringify(value) ?? \"null\";\n}\n\n/**\n * The bytes a manifest signature attests: the document minus its reserved\n * `signature` field, canonically serialized (key-sorted — the version-id\n * rule). The signer signs this before the field exists; the verifier\n * re-derives it from the parsed document, so the stored document's\n * whitespace never matters.\n */\nexport function signaturePayloadOf(manifest: WorkspaceVersionManifest): string {\n  const { signature: _signature, ...payload } = manifest;\n  return stableStringify(payload);\n}\n\n/** A published-artifact coordinate: object path within the bundle namespace + its served SRI. */\nexport type SourceRef = NonNullable<WorkspaceVersionManifest[\"source\"]>;\n\nexport interface VersionManifestInput {\n  /** Omit: a per-build timestamp makes the same version id map to different\n   * manifest bytes per machine, breaking the pin's SRI against the image's\n   * staged copy and the CDN's immutability for republished versions. */\n  builtAt?: string;\n  gitSha?: string;\n  dir?: string;\n  entry: string;\n  entryIntegrity: string;\n  ssr?: { entry: string; integrity: string };\n  browserManifest?: { file: string; integrity: string };\n  assets?: Record<string, string>;\n  shared?: Record<string, string>;\n  files?: Record<string, string>;\n  source?: { file: string; integrity: string };\n}\n\n/**\n * Compose the manifest with its `version` derived from the canonical content\n * of the artifact coordinates alone (key-sorted, `builtAt` excluded) —\n * identical bytes → identical version id regardless of when they were built,\n * so republishing unchanged content is a pointer no-op. Any changed\n * coordinate → a new version (and a new file).\n */\nexport function composeVersionManifest(input: VersionManifestInput): WorkspaceVersionManifest {\n  const { builtAt: _builtAt, ...hashedInputs } = input;\n  const version = createHash(\"sha256\")\n    .update(stableStringify(hashedInputs))\n    .digest(\"hex\")\n    .slice(0, 16);\n  return WorkspaceVersionManifestSchema.parse({ ...input, version });\n}\n\n/**\n * The content-addressed directory name for one dist's file set (#826): a\n * 16-hex hash over the canonical files map. Identical bytes → identical\n * directory → re-deploying unchanged content is a server-side no-op, and a\n * published pin's directory can never be rewritten by a later deploy\n * (the upload service refuses conflicting writes under `versions/`).\n */\nexport function versionDirPath(files: Record<string, string>): string {\n  const id = createHash(\"sha256\").update(stableStringify(files)).digest(\"hex\").slice(0, 16);\n  return `versions/${id}`;\n}\n"],"mappings":";;;;;;;;;;;;;AAYA,MAAM,MAAMA,MAAE,OAAO,CAAC,CAAC,MAAM,0BAA0B;;AAGvD,MAAa,sBAAsB;;;;;AAMnC,MAAa,0BAA0BA,MAAE,OAAO;CAC9C,WAAWA,MAAE,QAAQ,SAAS;;;CAG9B,WAAWA,MAAE,OAAO,CAAC,CAAC,IAAI,CAAC;;CAE3B,OAAOA,MAAE,OAAO,CAAC,CAAC,IAAI,CAAC;AACzB,CAAC;AAGD,MAAa,iCAAiCA,MAAE,OAAO;CACrD,SAASA,MAAE,OAAO,CAAC,CAAC,MAAM,gBAAgB;CAC1C,SAASA,MAAE,OAAO,CAAC,CAAC,SAAS;CAC7B,QAAQA,MAAE,OAAO,CAAC,CAAC,SAAS;;;;;;;;;;;CAW5B,KAAKA,MAAE,OAAO,CAAC,CAAC,MAAM,mBAAmB,CAAC,CAAC,SAAS;CACpD,OAAOA,MAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CACvB,gBAAgB;CAChB,KAAKA,MACF,OAAO;EACN,OAAOA,MAAE,OAAO,CAAC,CAAC,IAAI,CAAC;EACvB,WAAW;CACb,CAAC,CAAC,CACD,SAAS;CACZ,iBAAiBA,MACd,OAAO;EACN,MAAMA,MAAE,OAAO,CAAC,CAAC,IAAI,CAAC;EACtB,WAAW;CACb,CAAC,CAAC,CACD,SAAS;;CAEZ,QAAQA,MAAE,OAAOA,MAAE,OAAO,GAAG,GAAG,CAAC,CAAC,SAAS;;CAE3C,QAAQA,MAAE,OAAOA,MAAE,OAAO,GAAGA,MAAE,OAAO,CAAC,CAAC,CAAC,SAAS;;;;;;;CAOlD,OAAOA,MAAE,OAAOA,MAAE,OAAO,GAAG,GAAG,CAAC,CAAC,SAAS;;;;;;;;;CAS1C,QAAQA,MACL,OAAO;EACN,MAAMA,MAAE,OAAO,CAAC,CAAC,IAAI,CAAC;EACtB,WAAW;CACb,CAAC,CAAC,CACD,SAAS;;;;;;;;;;CAUZ,WAAW,wBAAwB,SAAS;AAC9C,CAAC;;;;;AAOD,SAAgB,gBAAgB,OAAwB;CACtD,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO,IAAI,MAAM,IAAI,eAAe,CAAC,CAAC,KAAK,GAAG,EAAE;CAC1E,IAAI,SAAS,OAAO,UAAU,UAC5B,OAAO,IAAI,OAAO,QAAQ,KAAK,CAAC,CAC7B,QAAQ,GAAG,OAAO,MAAM,MAAS,CAAC,CAClC,KAAK,CAAC,GAAG,OAAO,GAAG,KAAK,UAAU,CAAC,EAAE,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAC7D,KAAK,CAAC,CACN,KAAK,GAAG,EAAE;CAEf,OAAO,KAAK,UAAU,KAAK,KAAK;AAClC;;;;;;;;AASA,SAAgB,mBAAmB,UAA4C;CAC7E,MAAM,EAAE,WAAW,YAAY,GAAG,YAAY;CAC9C,OAAO,gBAAgB,OAAO;AAChC;;;;;;;;AA6BA,SAAgB,uBAAuB,OAAuD;CAC5F,MAAM,EAAE,SAAS,UAAU,GAAG,iBAAiB;CAC/C,MAAM,cAAUC,wBAAW,QAAQ,CAAC,CACjC,OAAO,gBAAgB,YAAY,CAAC,CAAC,CACrC,OAAO,KAAK,CAAC,CACb,MAAM,GAAG,EAAE;CACd,OAAO,+BAA+B,MAAM;EAAE,GAAG;EAAO;CAAQ,CAAC;AACnE;;;;;;;;AASA,SAAgB,eAAe,OAAuC;CAEpE,OAAO,gBADIA,wBAAW,QAAQ,CAAC,CAAC,OAAO,gBAAgB,KAAK,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,GAAG,EAClE;AACtB"}

package/dist/version-manifest.d.cts

@@ -1,9 +1,22 @@
 import { z } from "zod";
 //#region src/version-manifest.d.ts
+/** Slot-relative directory holding one deploy's immutable file copies (#826). */
+declare const VERSION_DIR_PATTERN: RegExp;
+/** The attribution block stored in the manifest's `signature` field. The
+ * verifying key rides along so a verifier can distinguish "wrong signature"
+ * from "signed by a key the config never registered" — both are
+ * `SignatureInvalid`, but the reasons name different compromises. */
+declare const ManifestSignatureSchema: z.ZodObject<{
+  algorithm: z.ZodLiteral<"ed25519">;
+  publicKey: z.ZodString;
+  value: z.ZodString;
+}, z.core.$strip>;
+type ManifestSignature = z.infer<typeof ManifestSignatureSchema>;
 declare const WorkspaceVersionManifestSchema: z.ZodObject<{
   version: z.ZodString;
   builtAt: z.ZodOptional<z.ZodString>;
   gitSha: z.ZodOptional<z.ZodString>;
+  dir: z.ZodOptional<z.ZodString>;
   entry: z.ZodString;
   entryIntegrity: z.ZodString;
   ssr: z.ZodOptional<z.ZodObject<{
@@ -21,8 +34,26 @@ declare const WorkspaceVersionManifestSchema: z.ZodObject<{
     file: z.ZodString;
     integrity: z.ZodString;
   }, z.core.$strip>>;
+  signature: z.ZodOptional<z.ZodObject<{
+    algorithm: z.ZodLiteral<"ed25519">;
+    publicKey: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strip>>;
 }, z.core.$strip>;
 type WorkspaceVersionManifest = z.infer<typeof WorkspaceVersionManifestSchema>;
+/** Canonical key-sorted JSON serialization — the same form the version-id
+ * derivation hashes (undefined-valued entries dropped). Exported so the
+ * signature payload and the version id can never disagree about what
+ * "canonical" means. */
+declare function stableStringify(value: unknown): string;
+/**
+ * The bytes a manifest signature attests: the document minus its reserved
+ * `signature` field, canonically serialized (key-sorted — the version-id
+ * rule). The signer signs this before the field exists; the verifier
+ * re-derives it from the parsed document, so the stored document's
+ * whitespace never matters.
+ */
+declare function signaturePayloadOf(manifest: WorkspaceVersionManifest): string;
 /** A published-artifact coordinate: object path within the bundle namespace + its served SRI. */
 type SourceRef = NonNullable<WorkspaceVersionManifest["source"]>;
 interface VersionManifestInput {
@@ -31,6 +62,7 @@ interface VersionManifestInput {
    * staged copy and the CDN's immutability for republished versions. */
   builtAt?: string;
   gitSha?: string;
+  dir?: string;
   entry: string;
   entryIntegrity: string;
   ssr?: {
@@ -57,6 +89,14 @@ interface VersionManifestInput {
  * coordinate → a new version (and a new file).
  */
 declare function composeVersionManifest(input: VersionManifestInput): WorkspaceVersionManifest;
+/**
+ * The content-addressed directory name for one dist's file set (#826): a
+ * 16-hex hash over the canonical files map. Identical bytes → identical
+ * directory → re-deploying unchanged content is a server-side no-op, and a
+ * published pin's directory can never be rewritten by a later deploy
+ * (the upload service refuses conflicting writes under `versions/`).
+ */
+declare function versionDirPath(files: Record<string, string>): string;
 //#endregion
-export { SourceRef, VersionManifestInput, WorkspaceVersionManifest, WorkspaceVersionManifestSchema, composeVersionManifest };
+export { ManifestSignature, ManifestSignatureSchema, SourceRef, VERSION_DIR_PATTERN, VersionManifestInput, WorkspaceVersionManifest, WorkspaceVersionManifestSchema, composeVersionManifest, signaturePayloadOf, stableStringify, versionDirPath };
 //# sourceMappingURL=version-manifest.d.cts.map

package/dist/version-manifest.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"version-manifest.d.cts","names":[],"sources":["../src/version-manifest.ts"],"mappings":";;cAca,gCAA8B,EAAA;;;;;;;;;;;;;;;;;;;;;GA2CzC,EAAA,KAAA;KACU,2BAA2B,EAAE,aAAa;;KAG1C,YAAY,YAAY;UAEnB;;;;EAIf;EACA;EACA;EACA;EACA;IAAQ;IAAe;;EACvB;IAAoB;IAAc;;EAClC,SAAS;EACT,SAAS;EACT,QAAQ;EACR;IAAW;IAAc;;;;;;;;;;iBAUX,uBAAuB,OAAO,uBAAuB"}
+{"version":3,"file":"version-manifest.d.cts","names":[],"sources":["../src/version-manifest.ts"],"mappings":";;;cAea,qBAAmB;;;;;cAMnB,yBAAuB,EAAA;;;;GAOlC,EAAA,KAAA;KACU,oBAAoB,EAAE,aAAa;cAElC,gCAA8B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEzC,EAAA,KAAA;KACU,2BAA2B,EAAE,aAAa;;;;;iBAMtC,gBAAgB;;;;;;;;iBAmBhB,mBAAmB,UAAU;;KAMjC,YAAY,YAAY;UAEnB;;;;EAIf;EACA;EACA;EACA;EACA;EACA;IAAQ;IAAe;;EACvB;IAAoB;IAAc;;EAClC,SAAS;EACT,SAAS;EACT,QAAQ;EACR;IAAW;IAAc;;;;;;;;;;iBAUX,uBAAuB,OAAO,uBAAuB;;;;;;;;iBAgBrD,eAAe,OAAO"}

package/dist/version-manifest.d.mts

@@ -1,9 +1,22 @@
 import { z } from "zod";
 //#region src/version-manifest.d.ts
+/** Slot-relative directory holding one deploy's immutable file copies (#826). */
+declare const VERSION_DIR_PATTERN: RegExp;
+/** The attribution block stored in the manifest's `signature` field. The
+ * verifying key rides along so a verifier can distinguish "wrong signature"
+ * from "signed by a key the config never registered" — both are
+ * `SignatureInvalid`, but the reasons name different compromises. */
+declare const ManifestSignatureSchema: z.ZodObject<{
+  algorithm: z.ZodLiteral<"ed25519">;
+  publicKey: z.ZodString;
+  value: z.ZodString;
+}, z.core.$strip>;
+type ManifestSignature = z.infer<typeof ManifestSignatureSchema>;
 declare const WorkspaceVersionManifestSchema: z.ZodObject<{
   version: z.ZodString;
   builtAt: z.ZodOptional<z.ZodString>;
   gitSha: z.ZodOptional<z.ZodString>;
+  dir: z.ZodOptional<z.ZodString>;
   entry: z.ZodString;
   entryIntegrity: z.ZodString;
   ssr: z.ZodOptional<z.ZodObject<{
@@ -21,8 +34,26 @@ declare const WorkspaceVersionManifestSchema: z.ZodObject<{
     file: z.ZodString;
     integrity: z.ZodString;
   }, z.core.$strip>>;
+  signature: z.ZodOptional<z.ZodObject<{
+    algorithm: z.ZodLiteral<"ed25519">;
+    publicKey: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strip>>;
 }, z.core.$strip>;
 type WorkspaceVersionManifest = z.infer<typeof WorkspaceVersionManifestSchema>;
+/** Canonical key-sorted JSON serialization — the same form the version-id
+ * derivation hashes (undefined-valued entries dropped). Exported so the
+ * signature payload and the version id can never disagree about what
+ * "canonical" means. */
+declare function stableStringify(value: unknown): string;
+/**
+ * The bytes a manifest signature attests: the document minus its reserved
+ * `signature` field, canonically serialized (key-sorted — the version-id
+ * rule). The signer signs this before the field exists; the verifier
+ * re-derives it from the parsed document, so the stored document's
+ * whitespace never matters.
+ */
+declare function signaturePayloadOf(manifest: WorkspaceVersionManifest): string;
 /** A published-artifact coordinate: object path within the bundle namespace + its served SRI. */
 type SourceRef = NonNullable<WorkspaceVersionManifest["source"]>;
 interface VersionManifestInput {
@@ -31,6 +62,7 @@ interface VersionManifestInput {
    * staged copy and the CDN's immutability for republished versions. */
   builtAt?: string;
   gitSha?: string;
+  dir?: string;
   entry: string;
   entryIntegrity: string;
   ssr?: {
@@ -57,6 +89,14 @@ interface VersionManifestInput {
  * coordinate → a new version (and a new file).
  */
 declare function composeVersionManifest(input: VersionManifestInput): WorkspaceVersionManifest;
+/**
+ * The content-addressed directory name for one dist's file set (#826): a
+ * 16-hex hash over the canonical files map. Identical bytes → identical
+ * directory → re-deploying unchanged content is a server-side no-op, and a
+ * published pin's directory can never be rewritten by a later deploy
+ * (the upload service refuses conflicting writes under `versions/`).
+ */
+declare function versionDirPath(files: Record<string, string>): string;
 //#endregion
-export { SourceRef, VersionManifestInput, WorkspaceVersionManifest, WorkspaceVersionManifestSchema, composeVersionManifest };
+export { ManifestSignature, ManifestSignatureSchema, SourceRef, VERSION_DIR_PATTERN, VersionManifestInput, WorkspaceVersionManifest, WorkspaceVersionManifestSchema, composeVersionManifest, signaturePayloadOf, stableStringify, versionDirPath };
 //# sourceMappingURL=version-manifest.d.mts.map

package/dist/version-manifest.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"version-manifest.d.mts","names":[],"sources":["../src/version-manifest.ts"],"mappings":";;cAca,gCAA8B,EAAA;;;;;;;;;;;;;;;;;;;;;GA2CzC,EAAA,KAAA;KACU,2BAA2B,EAAE,aAAa;;KAG1C,YAAY,YAAY;UAEnB;;;;EAIf;EACA;EACA;EACA;EACA;IAAQ;IAAe;;EACvB;IAAoB;IAAc;;EAClC,SAAS;EACT,SAAS;EACT,QAAQ;EACR;IAAW;IAAc;;;;;;;;;;iBAUX,uBAAuB,OAAO,uBAAuB"}
+{"version":3,"file":"version-manifest.d.mts","names":[],"sources":["../src/version-manifest.ts"],"mappings":";;;cAea,qBAAmB;;;;;cAMnB,yBAAuB,EAAA;;;;GAOlC,EAAA,KAAA;KACU,oBAAoB,EAAE,aAAa;cAElC,gCAA8B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEzC,EAAA,KAAA;KACU,2BAA2B,EAAE,aAAa;;;;;iBAMtC,gBAAgB;;;;;;;;iBAmBhB,mBAAmB,UAAU;;KAMjC,YAAY,YAAY;UAEnB;;;;EAIf;EACA;EACA;EACA;EACA;EACA;IAAQ;IAAe;;EACvB;IAAoB;IAAc;;EAClC,SAAS;EACT,SAAS;EACT,QAAQ;EACR;IAAW;IAAc;;;;;;;;;;iBAUX,uBAAuB,OAAO,uBAAuB;;;;;;;;iBAgBrD,eAAe,OAAO"}

package/dist/version-manifest.mjs

@@ -11,10 +11,35 @@ import { createHash } from "node:crypto";
 * stops growing with artifact kinds and old versions stay fully servable.
 */
 const SRI = z.string().regex(/^sha384-[A-Za-z0-9+/=]+$/);
+/** Slot-relative directory holding one deploy's immutable file copies (#826). */
+const VERSION_DIR_PATTERN = /^versions\/[0-9a-f]{16}$/;
+/** The attribution block stored in the manifest's `signature` field. The
+* verifying key rides along so a verifier can distinguish "wrong signature"
+* from "signed by a key the config never registered" — both are
+* `SignatureInvalid`, but the reasons name different compromises. */
+const ManifestSignatureSchema = z.object({
+	algorithm: z.literal("ed25519"),
+	/** NEAR-format verifying key (`ed25519:<base58>`) — must equal the
+	* config's `publish.verification.publicKey`. */
+	publicKey: z.string().min(1),
+	/** base64 ed25519 signature over the canonical payload bytes. */
+	value: z.string().min(1)
+});
 const WorkspaceVersionManifestSchema = z.object({
 	version: z.string().regex(/^[0-9a-f]{16}$/),
 	builtAt: z.string().optional(),
 	gitSha: z.string().optional(),
+	/**
+	* Slot-relative directory (`versions/<dirId>`) holding this deploy's
+	* byte-immutable copies of every dist file (#826). When present, all
+	* artifact coordinates below resolve against `<slotBase>/<dir>/` — so a
+	* pinned child's entry fetches its expose chunk and chunks from the same
+	* frozen directory instead of the mutable slot root. Absent on legacy
+	* manifests: coordinates resolve against the slot root exactly as before.
+	* Derived from the `files` map (see `versionDirPath`), so it participates
+	* in the version hash without circularity.
+	*/
+	dir: z.string().regex(VERSION_DIR_PATTERN).optional(),
 	entry: z.string().min(1),
 	entryIntegrity: SRI,
 	ssr: z.object({
@@ -47,8 +72,38 @@ const WorkspaceVersionManifestSchema = z.object({
 	source: z.object({
 		file: z.string().min(1),
 		integrity: SRI
-	}).optional()
+	}).optional(),
+	/**
+	* Attribution (ADR 0046 ticket 05): the deploy train's ed25519 signature
+	* over `signaturePayloadOf(this document)` — SRI attests WHAT the bytes
+	* are, the signature attests WHO published them, with the verifying key
+	* anchored in the on-chain config (`publish.verification`). Absent on
+	* rollouts with attribution off; readers that predate the field ignore it
+	* (zod strips unknown keys). Excluded from the version-id derivation —
+	* like `builtAt`, it is not a coordinate of the build.
+	*/
+	signature: ManifestSignatureSchema.optional()
 });
+/** Canonical key-sorted JSON serialization — the same form the version-id
+* derivation hashes (undefined-valued entries dropped). Exported so the
+* signature payload and the version id can never disagree about what
+* "canonical" means. */
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.entries(value).filter(([, v]) => v !== void 0).map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).sort().join(",")}}`;
+	return JSON.stringify(value) ?? "null";
+}
+/**
+* The bytes a manifest signature attests: the document minus its reserved
+* `signature` field, canonically serialized (key-sorted — the version-id
+* rule). The signer signs this before the field exists; the verifier
+* re-derives it from the parsed document, so the stored document's
+* whitespace never matters.
+*/
+function signaturePayloadOf(manifest) {
+	const { signature: _signature, ...payload } = manifest;
+	return stableStringify(payload);
+}
 /**
 * Compose the manifest with its `version` derived from the canonical content
 * of the artifact coordinates alone (key-sorted, `builtAt` excluded) —
@@ -64,12 +119,17 @@ function composeVersionManifest(input) {
 		version
 	});
 }
-function stableStringify(value) {
-	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
-	if (value && typeof value === "object") return `{${Object.entries(value).filter(([, v]) => v !== void 0).map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).sort().join(",")}}`;
-	return JSON.stringify(value) ?? "null";
+/**
+* The content-addressed directory name for one dist's file set (#826): a
+* 16-hex hash over the canonical files map. Identical bytes → identical
+* directory → re-deploying unchanged content is a server-side no-op, and a
+* published pin's directory can never be rewritten by a later deploy
+* (the upload service refuses conflicting writes under `versions/`).
+*/
+function versionDirPath(files) {
+	return `versions/${createHash("sha256").update(stableStringify(files)).digest("hex").slice(0, 16)}`;
 }
 
 //#endregion
-export { WorkspaceVersionManifestSchema, composeVersionManifest };
+export { ManifestSignatureSchema, VERSION_DIR_PATTERN, WorkspaceVersionManifestSchema, composeVersionManifest, signaturePayloadOf, stableStringify, versionDirPath };
 //# sourceMappingURL=version-manifest.mjs.map

package/dist/version-manifest.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"version-manifest.mjs","names":[],"sources":["../src/version-manifest.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { z } from \"zod\";\n\n/**\n * WorkspaceVersionManifest — the immutable per-deploy document at\n * `bundles/<account>/<gateway>/<workspace>/versions/<version>.json`\n * (ADR 0020, as amended; atomic-deploys MAP decision 1). The published\n * config's slot pins this document via its `pin` (`manifest` + the\n * manifest's own SRI); every artifact coordinate lives here, so the config\n * stops growing with artifact kinds and old versions stay fully servable.\n */\n\nconst SRI = z.string().regex(/^sha384-[A-Za-z0-9+/=]+$/);\n\nexport const WorkspaceVersionManifestSchema = z.object({\n  version: z.string().regex(/^[0-9a-f]{16}$/),\n  builtAt: z.string().optional(),\n  gitSha: z.string().optional(),\n  entry: z.string().min(1),\n  entryIntegrity: SRI,\n  ssr: z\n    .object({\n      entry: z.string().min(1),\n      integrity: SRI,\n    })\n    .optional(),\n  browserManifest: z\n    .object({\n      file: z.string().min(1),\n      integrity: SRI,\n    })\n    .optional(),\n  /** extra assets (css, icons) — logical name → served-object SRI */\n  assets: z.record(z.string(), SRI).optional(),\n  /** shared-dependency versions this build was built against */\n  shared: z.record(z.string(), z.string()).optional(),\n  /**\n   * Full per-file digest map of the dist (object path → served-object SRI).\n   * Written by `every-plugin`-based deploys so the next deploy can diff against\n   * it and skip re-uploading unchanged files; readers that predate the field\n   * ignore it (zod strips unknown keys). Participates in the version hash.\n   */\n  files: z.record(z.string(), SRI).optional(),\n  /**\n   * Source archive of the workspace subtree (object path → served-object SRI)\n   * published beside the dists when the runtime opts in via\n   * `publish.sourcePublish` — lets `bos import` dereference a published\n   * config slot to the exact source bytes that build came from, with no\n   * GitHub dependency. Readers that predate the field ignore it (zod strips\n   * unknown keys). Participates in the version hash.\n   */\n  source: z\n    .object({\n      file: z.string().min(1),\n      integrity: SRI,\n    })\n    .optional(),\n});\nexport type WorkspaceVersionManifest = z.infer<typeof WorkspaceVersionManifestSchema>;\n\n/** A published-artifact coordinate: object path within the bundle namespace + its served SRI. */\nexport type SourceRef = NonNullable<WorkspaceVersionManifest[\"source\"]>;\n\nexport interface VersionManifestInput {\n  /** Omit: a per-build timestamp makes the same version id map to different\n   * manifest bytes per machine, breaking the pin's SRI against the image's\n   * staged copy and the CDN's immutability for republished versions. */\n  builtAt?: string;\n  gitSha?: string;\n  entry: string;\n  entryIntegrity: string;\n  ssr?: { entry: string; integrity: string };\n  browserManifest?: { file: string; integrity: string };\n  assets?: Record<string, string>;\n  shared?: Record<string, string>;\n  files?: Record<string, string>;\n  source?: { file: string; integrity: string };\n}\n\n/**\n * Compose the manifest with its `version` derived from the canonical content\n * of the artifact coordinates alone (key-sorted, `builtAt` excluded) —\n * identical bytes → identical version id regardless of when they were built,\n * so republishing unchanged content is a pointer no-op. Any changed\n * coordinate → a new version (and a new file).\n */\nexport function composeVersionManifest(input: VersionManifestInput): WorkspaceVersionManifest {\n  const { builtAt: _builtAt, ...hashedInputs } = input;\n  const version = createHash(\"sha256\")\n    .update(stableStringify(hashedInputs))\n    .digest(\"hex\")\n    .slice(0, 16);\n  return WorkspaceVersionManifestSchema.parse({ ...input, version });\n}\n\nfunction stableStringify(value: unknown): string {\n  if (Array.isArray(value)) return `[${value.map(stableStringify).join(\",\")}]`;\n  if (value && typeof value === \"object\") {\n    return `{${Object.entries(value)\n      .filter(([, v]) => v !== undefined)\n      .map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`)\n      .sort()\n      .join(\",\")}}`;\n  }\n  return JSON.stringify(value) ?? \"null\";\n}\n"],"mappings":";;;;;;;;;;;;AAYA,MAAM,MAAM,EAAE,OAAO,CAAC,CAAC,MAAM,0BAA0B;AAEvD,MAAa,iCAAiC,EAAE,OAAO;CACrD,SAAS,EAAE,OAAO,CAAC,CAAC,MAAM,gBAAgB;CAC1C,SAAS,EAAE,OAAO,CAAC,CAAC,SAAS;CAC7B,QAAQ,EAAE,OAAO,CAAC,CAAC,SAAS;CAC5B,OAAO,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CACvB,gBAAgB;CAChB,KAAK,EACF,OAAO;EACN,OAAO,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;EACvB,WAAW;CACb,CAAC,CAAC,CACD,SAAS;CACZ,iBAAiB,EACd,OAAO;EACN,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;EACtB,WAAW;CACb,CAAC,CAAC,CACD,SAAS;;CAEZ,QAAQ,EAAE,OAAO,EAAE,OAAO,GAAG,GAAG,CAAC,CAAC,SAAS;;CAE3C,QAAQ,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC,SAAS;;;;;;;CAOlD,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,GAAG,CAAC,CAAC,SAAS;;;;;;;;;CAS1C,QAAQ,EACL,OAAO;EACN,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;EACtB,WAAW;CACb,CAAC,CAAC,CACD,SAAS;AACd,CAAC;;;;;;;;AA6BD,SAAgB,uBAAuB,OAAuD;CAC5F,MAAM,EAAE,SAAS,UAAU,GAAG,iBAAiB;CAC/C,MAAM,UAAU,WAAW,QAAQ,CAAC,CACjC,OAAO,gBAAgB,YAAY,CAAC,CAAC,CACrC,OAAO,KAAK,CAAC,CACb,MAAM,GAAG,EAAE;CACd,OAAO,+BAA+B,MAAM;EAAE,GAAG;EAAO;CAAQ,CAAC;AACnE;AAEA,SAAS,gBAAgB,OAAwB;CAC/C,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO,IAAI,MAAM,IAAI,eAAe,CAAC,CAAC,KAAK,GAAG,EAAE;CAC1E,IAAI,SAAS,OAAO,UAAU,UAC5B,OAAO,IAAI,OAAO,QAAQ,KAAK,CAAC,CAC7B,QAAQ,GAAG,OAAO,MAAM,MAAS,CAAC,CAClC,KAAK,CAAC,GAAG,OAAO,GAAG,KAAK,UAAU,CAAC,EAAE,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAC7D,KAAK,CAAC,CACN,KAAK,GAAG,EAAE;CAEf,OAAO,KAAK,UAAU,KAAK,KAAK;AAClC"}
+{"version":3,"file":"version-manifest.mjs","names":[],"sources":["../src/version-manifest.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { z } from \"zod\";\n\n/**\n * WorkspaceVersionManifest — the immutable per-deploy document at\n * `bundles/<account>/<gateway>/<workspace>/versions/<version>.json`\n * (ADR 0020, as amended; atomic-deploys MAP decision 1). The published\n * config's slot pins this document via its `pin` (`manifest` + the\n * manifest's own SRI); every artifact coordinate lives here, so the config\n * stops growing with artifact kinds and old versions stay fully servable.\n */\n\nconst SRI = z.string().regex(/^sha384-[A-Za-z0-9+/=]+$/);\n\n/** Slot-relative directory holding one deploy's immutable file copies (#826). */\nexport const VERSION_DIR_PATTERN = /^versions\\/[0-9a-f]{16}$/;\n\n/** The attribution block stored in the manifest's `signature` field. The\n * verifying key rides along so a verifier can distinguish \"wrong signature\"\n * from \"signed by a key the config never registered\" — both are\n * `SignatureInvalid`, but the reasons name different compromises. */\nexport const ManifestSignatureSchema = z.object({\n  algorithm: z.literal(\"ed25519\"),\n  /** NEAR-format verifying key (`ed25519:<base58>`) — must equal the\n   * config's `publish.verification.publicKey`. */\n  publicKey: z.string().min(1),\n  /** base64 ed25519 signature over the canonical payload bytes. */\n  value: z.string().min(1),\n});\nexport type ManifestSignature = z.infer<typeof ManifestSignatureSchema>;\n\nexport const WorkspaceVersionManifestSchema = z.object({\n  version: z.string().regex(/^[0-9a-f]{16}$/),\n  builtAt: z.string().optional(),\n  gitSha: z.string().optional(),\n  /**\n   * Slot-relative directory (`versions/<dirId>`) holding this deploy's\n   * byte-immutable copies of every dist file (#826). When present, all\n   * artifact coordinates below resolve against `<slotBase>/<dir>/` — so a\n   * pinned child's entry fetches its expose chunk and chunks from the same\n   * frozen directory instead of the mutable slot root. Absent on legacy\n   * manifests: coordinates resolve against the slot root exactly as before.\n   * Derived from the `files` map (see `versionDirPath`), so it participates\n   * in the version hash without circularity.\n   */\n  dir: z.string().regex(VERSION_DIR_PATTERN).optional(),\n  entry: z.string().min(1),\n  entryIntegrity: SRI,\n  ssr: z\n    .object({\n      entry: z.string().min(1),\n      integrity: SRI,\n    })\n    .optional(),\n  browserManifest: z\n    .object({\n      file: z.string().min(1),\n      integrity: SRI,\n    })\n    .optional(),\n  /** extra assets (css, icons) — logical name → served-object SRI */\n  assets: z.record(z.string(), SRI).optional(),\n  /** shared-dependency versions this build was built against */\n  shared: z.record(z.string(), z.string()).optional(),\n  /**\n   * Full per-file digest map of the dist (object path → served-object SRI).\n   * Written by `every-plugin`-based deploys so the next deploy can diff against\n   * it and skip re-uploading unchanged files; readers that predate the field\n   * ignore it (zod strips unknown keys). Participates in the version hash.\n   */\n  files: z.record(z.string(), SRI).optional(),\n  /**\n   * Source archive of the workspace subtree (object path → served-object SRI)\n   * published beside the dists when the runtime opts in via\n   * `publish.sourcePublish` — lets `bos import` dereference a published\n   * config slot to the exact source bytes that build came from, with no\n   * GitHub dependency. Readers that predate the field ignore it (zod strips\n   * unknown keys). Participates in the version hash.\n   */\n  source: z\n    .object({\n      file: z.string().min(1),\n      integrity: SRI,\n    })\n    .optional(),\n  /**\n   * Attribution (ADR 0046 ticket 05): the deploy train's ed25519 signature\n   * over `signaturePayloadOf(this document)` — SRI attests WHAT the bytes\n   * are, the signature attests WHO published them, with the verifying key\n   * anchored in the on-chain config (`publish.verification`). Absent on\n   * rollouts with attribution off; readers that predate the field ignore it\n   * (zod strips unknown keys). Excluded from the version-id derivation —\n   * like `builtAt`, it is not a coordinate of the build.\n   */\n  signature: ManifestSignatureSchema.optional(),\n});\nexport type WorkspaceVersionManifest = z.infer<typeof WorkspaceVersionManifestSchema>;\n\n/** Canonical key-sorted JSON serialization — the same form the version-id\n * derivation hashes (undefined-valued entries dropped). Exported so the\n * signature payload and the version id can never disagree about what\n * \"canonical\" means. */\nexport function stableStringify(value: unknown): string {\n  if (Array.isArray(value)) return `[${value.map(stableStringify).join(\",\")}]`;\n  if (value && typeof value === \"object\") {\n    return `{${Object.entries(value)\n      .filter(([, v]) => v !== undefined)\n      .map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`)\n      .sort()\n      .join(\",\")}}`;\n  }\n  return JSON.stringify(value) ?? \"null\";\n}\n\n/**\n * The bytes a manifest signature attests: the document minus its reserved\n * `signature` field, canonically serialized (key-sorted — the version-id\n * rule). The signer signs this before the field exists; the verifier\n * re-derives it from the parsed document, so the stored document's\n * whitespace never matters.\n */\nexport function signaturePayloadOf(manifest: WorkspaceVersionManifest): string {\n  const { signature: _signature, ...payload } = manifest;\n  return stableStringify(payload);\n}\n\n/** A published-artifact coordinate: object path within the bundle namespace + its served SRI. */\nexport type SourceRef = NonNullable<WorkspaceVersionManifest[\"source\"]>;\n\nexport interface VersionManifestInput {\n  /** Omit: a per-build timestamp makes the same version id map to different\n   * manifest bytes per machine, breaking the pin's SRI against the image's\n   * staged copy and the CDN's immutability for republished versions. */\n  builtAt?: string;\n  gitSha?: string;\n  dir?: string;\n  entry: string;\n  entryIntegrity: string;\n  ssr?: { entry: string; integrity: string };\n  browserManifest?: { file: string; integrity: string };\n  assets?: Record<string, string>;\n  shared?: Record<string, string>;\n  files?: Record<string, string>;\n  source?: { file: string; integrity: string };\n}\n\n/**\n * Compose the manifest with its `version` derived from the canonical content\n * of the artifact coordinates alone (key-sorted, `builtAt` excluded) —\n * identical bytes → identical version id regardless of when they were built,\n * so republishing unchanged content is a pointer no-op. Any changed\n * coordinate → a new version (and a new file).\n */\nexport function composeVersionManifest(input: VersionManifestInput): WorkspaceVersionManifest {\n  const { builtAt: _builtAt, ...hashedInputs } = input;\n  const version = createHash(\"sha256\")\n    .update(stableStringify(hashedInputs))\n    .digest(\"hex\")\n    .slice(0, 16);\n  return WorkspaceVersionManifestSchema.parse({ ...input, version });\n}\n\n/**\n * The content-addressed directory name for one dist's file set (#826): a\n * 16-hex hash over the canonical files map. Identical bytes → identical\n * directory → re-deploying unchanged content is a server-side no-op, and a\n * published pin's directory can never be rewritten by a later deploy\n * (the upload service refuses conflicting writes under `versions/`).\n */\nexport function versionDirPath(files: Record<string, string>): string {\n  const id = createHash(\"sha256\").update(stableStringify(files)).digest(\"hex\").slice(0, 16);\n  return `versions/${id}`;\n}\n"],"mappings":";;;;;;;;;;;;AAYA,MAAM,MAAM,EAAE,OAAO,CAAC,CAAC,MAAM,0BAA0B;;AAGvD,MAAa,sBAAsB;;;;;AAMnC,MAAa,0BAA0B,EAAE,OAAO;CAC9C,WAAW,EAAE,QAAQ,SAAS;;;CAG9B,WAAW,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;;CAE3B,OAAO,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;AACzB,CAAC;AAGD,MAAa,iCAAiC,EAAE,OAAO;CACrD,SAAS,EAAE,OAAO,CAAC,CAAC,MAAM,gBAAgB;CAC1C,SAAS,EAAE,OAAO,CAAC,CAAC,SAAS;CAC7B,QAAQ,EAAE,OAAO,CAAC,CAAC,SAAS;;;;;;;;;;;CAW5B,KAAK,EAAE,OAAO,CAAC,CAAC,MAAM,mBAAmB,CAAC,CAAC,SAAS;CACpD,OAAO,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CACvB,gBAAgB;CAChB,KAAK,EACF,OAAO;EACN,OAAO,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;EACvB,WAAW;CACb,CAAC,CAAC,CACD,SAAS;CACZ,iBAAiB,EACd,OAAO;EACN,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;EACtB,WAAW;CACb,CAAC,CAAC,CACD,SAAS;;CAEZ,QAAQ,EAAE,OAAO,EAAE,OAAO,GAAG,GAAG,CAAC,CAAC,SAAS;;CAE3C,QAAQ,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC,SAAS;;;;;;;CAOlD,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,GAAG,CAAC,CAAC,SAAS;;;;;;;;;CAS1C,QAAQ,EACL,OAAO;EACN,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;EACtB,WAAW;CACb,CAAC,CAAC,CACD,SAAS;;;;;;;;;;CAUZ,WAAW,wBAAwB,SAAS;AAC9C,CAAC;;;;;AAOD,SAAgB,gBAAgB,OAAwB;CACtD,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO,IAAI,MAAM,IAAI,eAAe,CAAC,CAAC,KAAK,GAAG,EAAE;CAC1E,IAAI,SAAS,OAAO,UAAU,UAC5B,OAAO,IAAI,OAAO,QAAQ,KAAK,CAAC,CAC7B,QAAQ,GAAG,OAAO,MAAM,MAAS,CAAC,CAClC,KAAK,CAAC,GAAG,OAAO,GAAG,KAAK,UAAU,CAAC,EAAE,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAC7D,KAAK,CAAC,CACN,KAAK,GAAG,EAAE;CAEf,OAAO,KAAK,UAAU,KAAK,KAAK;AAClC;;;;;;;;AASA,SAAgB,mBAAmB,UAA4C;CAC7E,MAAM,EAAE,WAAW,YAAY,GAAG,YAAY;CAC9C,OAAO,gBAAgB,OAAO;AAChC;;;;;;;;AA6BA,SAAgB,uBAAuB,OAAuD;CAC5F,MAAM,EAAE,SAAS,UAAU,GAAG,iBAAiB;CAC/C,MAAM,UAAU,WAAW,QAAQ,CAAC,CACjC,OAAO,gBAAgB,YAAY,CAAC,CAAC,CACrC,OAAO,KAAK,CAAC,CACb,MAAM,GAAG,EAAE;CACd,OAAO,+BAA+B,MAAM;EAAE,GAAG;EAAO;CAAQ,CAAC;AACnE;;;;;;;;AASA,SAAgB,eAAe,OAAuC;CAEpE,OAAO,YADI,WAAW,QAAQ,CAAC,CAAC,OAAO,gBAAgB,KAAK,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,GAAG,EAClE;AACtB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "every-plugin",
-  "version": "3.0.0-rc.15",
+  "version": "3.0.0-rc.17",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/skills/plugin-client/SKILL.md

@@ -416,7 +416,7 @@ A child project inherits the parent's host, API, auth, and plugins via the `exte
 
 ```json
 {
-  "extends": "bos://dev.everything.near/dev.everything.dev",
+  "extends": "bos://dev.everything.near/everything.dev",
   "account": "myapp.near",
   "domain": "myapp.everything.dev"
 }
@@ -433,7 +433,7 @@ This inherits:
 
 ```bash
 bos init myapp.everything.dev \
-  --extends dev.everything.near/dev.everything.dev \
+  --extends dev.everything.near/everything.dev \
   --overrides ui,plugins \
   --plugins apps,template
 ```
@@ -470,6 +470,6 @@ See the `extends-config` skill for deep merge semantics, per-environment extends
 | 401 `UNAUTHORIZED` "API key required" with `data: { authType: "apiKey", hint: "Provide a valid API key via x-api-key header" }` | the route is `requireApiKey(...)`-protected and your key was absent — usually `Authorization: Bearer` was used instead | switch to the `x-api-key` header |
 | 403 `FORBIDDEN` "API key lacks permission: <resource>:<action>" with `data: { requiredPermissions, keyPermissions }` | the key's `permissions` map does not cover every required resource/action — partial matches are rejected | re-create (server-side) or update the key with the needed permissions |
 | 403 `FORBIDDEN` "Requires role: ..." / "Requires organization role: ..." | session role gate | sign in with an account holding the role; a key cannot satisfy these |
-| 403 `FORBIDDEN` "Organization requires platform-admin approval" | the org's `status` is not `"active"` | stop — needs platform-admin approval, no client-side fix |
+| 403 `FORBIDDEN` "Organization requires platform-admin approval" | a downstream app still runs its own approval middleware (this platform ships none) | app-level policy — surface the org's approval state to the user |
 | `authClient.apiKey.list` / `update` return only `prefix` and metadata | expected — the full secret is returned once at `create` | create a new key; the old secret is unrecoverable |
 | Browser request blocked by CORS despite a valid key | session cookies not sent (`credentials: "include"` missing) or origin not allowed by `CORS_ORIGIN` | add `credentials: "include"` to the fetch wrapper, or fix `CORS_ORIGIN` |

package/src/build/artifact-names.ts

@@ -34,13 +34,16 @@ export function uiEntryFilename(input: { isBuild: boolean; server?: boolean }):
 const HASH_SEGMENT_PATTERN = /\.[a-f0-9]{8,}\./;
 
 /**
- * Serving classification for bundle objects: anything whose name carries a
- * content-hash segment (including hashed entrypoints like
- * `remoteEntry.8f3a….js`) is immutable by construction; fixed-name
- * entrypoints and non-hashed files a redeploy replaces in place must
- * revalidate.
+ * Serving classification for bundle objects: anything under a version
+ * directory (`versions/<dirId>/…`, #826) or a `versions/<id>.json` manifest
+ * is immutable by construction — the directory name is content-addressed and
+ * the upload service refuses conflicting writes under `versions/`; likewise
+ * any name carrying a content-hash segment (including hashed entrypoints
+ * like `remoteEntry.8f3a….js`). Fixed-name entrypoints and non-hashed files
+ * a redeploy replaces in place must revalidate.
  */
 export function isImmutableBundlePath(name: string): boolean {
+  if (name === "versions" || name.startsWith("versions/")) return true;
   const base = name.split("/").pop() ?? name;
   return HASH_SEGMENT_PATTERN.test(base);
 }

package/src/build/ui/stubs.ts

@@ -65,19 +65,14 @@ export type {
   ConstructedTree,
   ConstructInput,
   ConstructPluginRef,
-  GateUser,
-  HostContext,
   NavManifest,
   PluginManifest,
   ResolvedPlugin,
   RouteConfigModule,
   RouteOptionsBundle,
 } from "everything-dev/ui/manifest";
-export {
-  CORE_UI_PLUGIN_KEY,
-  ComposePayloadSchema,
-  constructTree,
-} from "everything-dev/ui/manifest";
+export { CORE_UI_PLUGIN_KEY, ComposePayloadSchema } from "everything-dev/ui/manifest";
+export { constructTree } from "everything-dev/ui/compose";
 `,
   "src/globals.gen.ts": `// GENERATED FILE — do not edit. Regenerated from the installed framework version
 // by \`bos dev\` / \`bos build\` / \`bos typecheck\` (gitignored).