@usefragments/core 1.0.0

package/dist/chunk-YF65VYRY.js

@@ -0,0 +1,493 @@
+import {
+  portableRepoPathError
+} from "./chunk-EIYNNS77.js";
+
+// src/registry.ts
+import { z } from "zod";
+
+// src/contract/hash.ts
+function normalizeNumber(value) {
+  if (Number.isNaN(value)) return '"@num:nan"';
+  if (value === Infinity) return '"@num:+inf"';
+  if (value === -Infinity) return '"@num:-inf"';
+  if (Object.is(value, -0)) return "0";
+  return JSON.stringify(value);
+}
+function canonicalPreimage(value) {
+  if (value === void 0 || value === null) return "null";
+  const type = typeof value;
+  if (type === "number") return normalizeNumber(value);
+  if (type === "string" || type === "boolean") return JSON.stringify(value);
+  if (type === "bigint") return JSON.stringify(value.toString());
+  if (Array.isArray(value)) {
+    return `[${value.map(canonicalPreimage).join(",")}]`;
+  }
+  if (type !== "object") {
+    return "null";
+  }
+  const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalPreimage(v)}`).join(",")}}`;
+}
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+function rotr(value, bits) {
+  return (value >>> bits | value << 32 - bits) >>> 0;
+}
+function sha256Hex(message) {
+  const bytes = new TextEncoder().encode(message);
+  const length = bytes.length;
+  const bitLength = length * 8;
+  const withMarker = length + 1;
+  const zeroPad = (56 - withMarker % 64 + 64) % 64;
+  const total = withMarker + zeroPad + 8;
+  const buffer = new Uint8Array(total);
+  buffer.set(bytes, 0);
+  buffer[length] = 128;
+  const view = new DataView(buffer.buffer);
+  view.setUint32(total - 8, Math.floor(bitLength / 4294967296));
+  view.setUint32(total - 4, bitLength >>> 0);
+  let h0 = 1779033703;
+  let h1 = 3144134277;
+  let h2 = 1013904242;
+  let h3 = 2773480762;
+  let h4 = 1359893119;
+  let h5 = 2600822924;
+  let h6 = 528734635;
+  let h7 = 1541459225;
+  const w = new Uint32Array(64);
+  for (let chunk = 0; chunk < total; chunk += 64) {
+    for (let t = 0; t < 16; t++) w[t] = view.getUint32(chunk + t * 4);
+    for (let t = 16; t < 64; t++) {
+      const w15 = w[t - 15];
+      const w2 = w[t - 2];
+      const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ w15 >>> 3;
+      const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ w2 >>> 10;
+      w[t] = w[t - 16] + s0 + w[t - 7] + s1 >>> 0;
+    }
+    let a = h0;
+    let b = h1;
+    let c = h2;
+    let d = h3;
+    let e = h4;
+    let f = h5;
+    let g = h6;
+    let h = h7;
+    for (let t = 0; t < 64; t++) {
+      const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = h + s1 + ch + K[t] + w[t] >>> 0;
+      const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = s0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    h0 = h0 + a >>> 0;
+    h1 = h1 + b >>> 0;
+    h2 = h2 + c >>> 0;
+    h3 = h3 + d >>> 0;
+    h4 = h4 + e >>> 0;
+    h5 = h5 + f >>> 0;
+    h6 = h6 + g >>> 0;
+    h7 = h7 + h >>> 0;
+  }
+  return [h0, h1, h2, h3, h4, h5, h6, h7].map((value) => value.toString(16).padStart(8, "0")).join("");
+}
+function contractHash(body) {
+  return sha256Hex(canonicalPreimage(body));
+}
+
+// src/registry.ts
+var REGISTRY_MANIFEST_SCHEMA_VERSION = "fragments.registry.v1";
+var REGISTRY_ARTIFACT_SCHEMA_VERSION = "fragments.registry-artifact.v1";
+var REGISTRY_INSTALL_RECEIPT_SCHEMA_VERSION = "fragments.registry-lock.v1";
+var sha256Schema = z.string().regex(/^[0-9a-f]{64}$/);
+var registryPathSchema = z.string().min(1).superRefine((value, ctx) => {
+  const error = portableRepoPathError(value);
+  if (error) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, message: error });
+  }
+});
+var registryFilePathSchema = registryPathSchema.superRefine((value, ctx) => {
+  if (value === ".") {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "File path must point to a file, not the package root"
+    });
+  }
+});
+var registryDependencyTypeSchema = z.enum(["runtime", "peer", "dev", "optional"]);
+var registryDependencySchema = z.object({
+  name: z.string().min(1),
+  versionRange: z.string().min(1),
+  type: registryDependencyTypeSchema,
+  optional: z.boolean().optional()
+});
+var registryFileRoleSchema = z.enum([
+  "source",
+  "style",
+  "token",
+  "contract",
+  "test",
+  "story",
+  "example",
+  "asset",
+  "barrel",
+  "metadata"
+]);
+var registryFileSchema = z.object({
+  path: registryFilePathSchema,
+  role: registryFileRoleSchema,
+  sha256: sha256Schema,
+  size: z.number().int().nonnegative(),
+  contentType: z.string().min(1),
+  contentRef: z.string().min(1)
+});
+var registryFileContentSchema = z.object({
+  path: registryFilePathSchema,
+  content: z.string(),
+  sha256: sha256Schema,
+  size: z.number().int().nonnegative(),
+  contentType: z.string().min(1)
+});
+var registrySourceSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("package"),
+    packageName: z.string().min(1),
+    version: z.string().optional(),
+    rootPath: registryPathSchema.optional(),
+    commitSha: z.string().optional()
+  }),
+  z.object({
+    kind: z.literal("github"),
+    repoFullName: z.string().min(1),
+    commitSha: z.string().min(1),
+    path: registryPathSchema.optional()
+  }),
+  z.object({
+    kind: z.literal("local"),
+    rootPath: registryPathSchema.optional(),
+    commitSha: z.string().optional()
+  }),
+  z.object({
+    kind: z.literal("manual"),
+    label: z.string().min(1)
+  })
+]);
+var registryComponentExportSchema = z.object({
+  name: z.string().min(1),
+  kind: z.enum(["component", "hook", "utility", "type", "style"]).default("component"),
+  path: registryFilePathSchema.optional()
+});
+var registryComponentSchema = z.object({
+  componentId: z.string().min(1),
+  publicRef: z.string().min(1),
+  name: z.string().min(1),
+  status: z.string().min(1).default("stable"),
+  tier: z.enum(["core", "composition", "utility", "custom"]).default("core"),
+  category: z.string().optional(),
+  files: z.array(registryFileSchema).min(1),
+  styleFiles: z.array(registryFilePathSchema).default([]),
+  tokenDependencies: z.array(z.string().min(1)).default([]),
+  runtimeDependencies: z.array(registryDependencySchema).default([]),
+  peerDependencies: z.array(registryDependencySchema).default([]),
+  internalDependencies: z.array(z.string().min(1)).default([]),
+  exports: z.array(registryComponentExportSchema).default([]),
+  contract: z.unknown().optional(),
+  examples: z.array(z.unknown()).default([]),
+  provenance: z.record(z.unknown()).default({})
+});
+var registryEntrypointSchema = z.object({
+  specifier: z.string().min(1),
+  sourcePath: registryFilePathSchema
+});
+var registryInstallProfileSchema = z.object({
+  name: z.string().min(1),
+  targetPath: registryPathSchema,
+  importPath: z.string().min(1),
+  stylePath: registryPathSchema.optional(),
+  includeTests: z.boolean().default(false)
+});
+var registryManifestBaseSchema = z.object({
+  schemaVersion: z.literal(REGISTRY_MANIFEST_SCHEMA_VERSION),
+  registryId: z.string().min(1),
+  name: z.string().min(1),
+  channel: z.string().min(1),
+  version: z.string().min(1),
+  contractVersionId: z.string().optional(),
+  fcid: sha256Schema.optional(),
+  generatedAt: z.string().datetime(),
+  source: registrySourceSchema,
+  packageFiles: z.array(registryFileSchema).default([]),
+  entrypoints: z.array(registryEntrypointSchema).default([]),
+  components: z.record(z.string(), registryComponentSchema),
+  dependencies: z.array(registryDependencySchema).default([]),
+  installProfiles: z.array(registryInstallProfileSchema).default([])
+});
+var registryManifestDraftSchema = registryManifestBaseSchema;
+var registryManifestSchema = registryManifestBaseSchema.extend({
+  registryHash: sha256Schema
+});
+var registryArtifactSchema = z.object({
+  schemaVersion: z.literal(REGISTRY_ARTIFACT_SCHEMA_VERSION),
+  manifest: registryManifestSchema,
+  files: z.record(registryFilePathSchema, registryFileContentSchema)
+}).superRefine((artifact, ctx) => {
+  const filesByPath = artifact.files;
+  for (const [path, content] of Object.entries(filesByPath)) {
+    if (content.path !== path) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["files", path, "path"],
+        message: `Registry file map key ${path} does not match content path ${content.path}`
+      });
+    }
+  }
+  const manifestFiles = [
+    ...artifact.manifest.packageFiles,
+    ...artifact.manifest.entrypoints.map((entrypoint) => ({
+      path: entrypoint.sourcePath,
+      role: "barrel",
+      sha256: filesByPath[entrypoint.sourcePath]?.sha256 ?? "",
+      size: filesByPath[entrypoint.sourcePath]?.size ?? 0,
+      contentType: filesByPath[entrypoint.sourcePath]?.contentType ?? "text/plain",
+      contentRef: `sha256:${filesByPath[entrypoint.sourcePath]?.sha256 ?? ""}`
+    })),
+    ...Object.values(artifact.manifest.components).flatMap((component) => component.files)
+  ];
+  for (const file of manifestFiles) {
+    const content = filesByPath[file.path];
+    if (!content) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["files", file.path],
+        message: `Missing content for registry file ${file.path}`
+      });
+      continue;
+    }
+    if (content.sha256 !== file.sha256) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["files", file.path, "sha256"],
+        message: `Content hash for ${file.path} does not match manifest`
+      });
+    }
+    if (content.size !== file.size) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["files", file.path, "size"],
+        message: `Content size for ${file.path} does not match manifest`
+      });
+    }
+  }
+});
+var registryInstallReceiptFileSchema = z.object({
+  path: registryFilePathSchema,
+  sha256: sha256Schema,
+  sourcePath: registryFilePathSchema,
+  componentId: z.string().min(1).optional()
+});
+var registryInstallReceiptComponentSchema = z.object({
+  componentId: z.string().min(1),
+  publicRef: z.string().min(1),
+  name: z.string().min(1),
+  files: z.array(registryFilePathSchema)
+});
+var registryInstallReceiptSchema = z.object({
+  schemaVersion: z.literal(REGISTRY_INSTALL_RECEIPT_SCHEMA_VERSION),
+  registryId: z.string().min(1),
+  registryVersion: z.string().min(1),
+  registryHash: sha256Schema,
+  fcid: sha256Schema.optional(),
+  channel: z.string().min(1).optional(),
+  targetPath: registryPathSchema,
+  importPath: z.string().min(1),
+  installedComponents: z.array(registryInstallReceiptComponentSchema),
+  files: z.array(registryInstallReceiptFileSchema),
+  dependencies: z.array(registryDependencySchema).default([]),
+  installedAt: z.string().datetime()
+});
+function registryHashPayload(manifest) {
+  const { generatedAt: _generatedAt, ...withoutGeneratedAt } = manifest;
+  if ("registryHash" in withoutGeneratedAt) {
+    const { registryHash: _registryHash, ...withoutHash } = withoutGeneratedAt;
+    return withoutHash;
+  }
+  return withoutGeneratedAt;
+}
+function computeRegistryHash(manifest) {
+  return contractHash(registryHashPayload(manifest));
+}
+function finalizeRegistryManifest(input) {
+  const draft = registryManifestDraftSchema.parse(input);
+  return registryManifestSchema.parse({
+    ...draft,
+    registryHash: computeRegistryHash(draft)
+  });
+}
+function hashRegistryFileContent(content) {
+  return sha256Hex(content);
+}
+function registryFileSize(content) {
+  return new TextEncoder().encode(content).length;
+}
+function buildRegistryFile(input) {
+  const sha256 = hashRegistryFileContent(input.content);
+  const size = registryFileSize(input.content);
+  const path = registryFilePathSchema.parse(input.path);
+  const contentType = z.string().min(1).parse(input.contentType);
+  return {
+    metadata: registryFileSchema.parse({
+      path,
+      role: input.role,
+      sha256,
+      size,
+      contentType,
+      contentRef: input.contentRef ?? `sha256:${sha256}`
+    }),
+    content: registryFileContentSchema.parse({
+      path,
+      content: input.content,
+      sha256,
+      size,
+      contentType
+    })
+  };
+}
+function buildRegistryArtifact(input) {
+  const manifest = finalizeRegistryManifest(input.manifest);
+  const files = /* @__PURE__ */ new Map();
+  for (const file of input.files) {
+    const content = registryFileContentSchema.parse(file);
+    if (files.has(content.path)) {
+      throw new Error(`Duplicate registry file content for ${content.path}`);
+    }
+    files.set(content.path, content);
+  }
+  return registryArtifactSchema.parse({
+    schemaVersion: REGISTRY_ARTIFACT_SCHEMA_VERSION,
+    manifest,
+    files: Object.fromEntries(files)
+  });
+}
+function assertValidRegistryArtifact(artifact) {
+  return registryArtifactSchema.parse(artifact);
+}
+function registryArtifactDigest(artifact) {
+  const files = Object.fromEntries(
+    Object.entries(artifact.files).map(([path, file]) => [path, { sha256: file.sha256, size: file.size }]).sort(([leftPath], [rightPath]) => leftPath.localeCompare(rightPath))
+  );
+  return contractHash({
+    schemaVersion: artifact.schemaVersion,
+    manifest: registryHashPayload(artifact.manifest),
+    files
+  });
+}
+function registryManifestCanonicalPreimage(manifest) {
+  return canonicalPreimage(registryHashPayload(manifest));
+}
+
+export {
+  canonicalPreimage,
+  sha256Hex,
+  contractHash,
+  REGISTRY_MANIFEST_SCHEMA_VERSION,
+  REGISTRY_ARTIFACT_SCHEMA_VERSION,
+  REGISTRY_INSTALL_RECEIPT_SCHEMA_VERSION,
+  registryDependencyTypeSchema,
+  registryDependencySchema,
+  registryFileRoleSchema,
+  registryFileSchema,
+  registryFileContentSchema,
+  registrySourceSchema,
+  registryComponentExportSchema,
+  registryComponentSchema,
+  registryEntrypointSchema,
+  registryInstallProfileSchema,
+  registryManifestDraftSchema,
+  registryManifestSchema,
+  registryArtifactSchema,
+  registryInstallReceiptFileSchema,
+  registryInstallReceiptComponentSchema,
+  registryInstallReceiptSchema,
+  computeRegistryHash,
+  finalizeRegistryManifest,
+  hashRegistryFileContent,
+  registryFileSize,
+  buildRegistryFile,
+  buildRegistryArtifact,
+  assertValidRegistryArtifact,
+  registryArtifactDigest,
+  registryManifestCanonicalPreimage
+};
+//# sourceMappingURL=chunk-YF65VYRY.js.map

package/dist/chunk-YF65VYRY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/registry.ts","../src/contract/hash.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { portableRepoPathError } from \"./config-paths.js\";\nimport { canonicalPreimage, contractHash, sha256Hex } from \"./contract/hash.js\";\n\nexport const REGISTRY_MANIFEST_SCHEMA_VERSION = \"fragments.registry.v1\";\nexport const REGISTRY_ARTIFACT_SCHEMA_VERSION = \"fragments.registry-artifact.v1\";\nexport const REGISTRY_INSTALL_RECEIPT_SCHEMA_VERSION = \"fragments.registry-lock.v1\";\n\nconst sha256Schema = z.string().regex(/^[0-9a-f]{64}$/);\n\nconst registryPathSchema = z\n  .string()\n  .min(1)\n  .superRefine((value, ctx) => {\n    const error = portableRepoPathError(value);\n    if (error) {\n      ctx.addIssue({ code: z.ZodIssueCode.custom, message: error });\n    }\n  });\n\nconst registryFilePathSchema = registryPathSchema.superRefine((value, ctx) => {\n  if (value === \".\") {\n    ctx.addIssue({\n      code: z.ZodIssueCode.custom,\n      message: \"File path must point to a file, not the package root\",\n    });\n  }\n});\n\nexport const registryDependencyTypeSchema = z.enum([\"runtime\", \"peer\", \"dev\", \"optional\"]);\n\nexport const registryDependencySchema = z.object({\n  name: z.string().min(1),\n  versionRange: z.string().min(1),\n  type: registryDependencyTypeSchema,\n  optional: z.boolean().optional(),\n});\n\nexport const registryFileRoleSchema = z.enum([\n  \"source\",\n  \"style\",\n  \"token\",\n  \"contract\",\n  \"test\",\n  \"story\",\n  \"example\",\n  \"asset\",\n  \"barrel\",\n  \"metadata\",\n]);\n\nexport const registryFileSchema = z.object({\n  path: registryFilePathSchema,\n  role: registryFileRoleSchema,\n  sha256: sha256Schema,\n  size: z.number().int().nonnegative(),\n  contentType: z.string().min(1),\n  contentRef: z.string().min(1),\n});\n\nexport const registryFileContentSchema = z.object({\n  path: registryFilePathSchema,\n  content: z.string(),\n  sha256: sha256Schema,\n  size: z.number().int().nonnegative(),\n  contentType: z.string().min(1),\n});\n\nexport const registrySourceSchema = z.discriminatedUnion(\"kind\", [\n  z.object({\n    kind: z.literal(\"package\"),\n    packageName: z.string().min(1),\n    version: z.string().optional(),\n    rootPath: registryPathSchema.optional(),\n    commitSha: z.string().optional(),\n  }),\n  z.object({\n    kind: z.literal(\"github\"),\n    repoFullName: z.string().min(1),\n    commitSha: z.string().min(1),\n    path: registryPathSchema.optional(),\n  }),\n  z.object({\n    kind: z.literal(\"local\"),\n    rootPath: registryPathSchema.optional(),\n    commitSha: z.string().optional(),\n  }),\n  z.object({\n    kind: z.literal(\"manual\"),\n    label: z.string().min(1),\n  }),\n]);\n\nexport const registryComponentExportSchema = z.object({\n  name: z.string().min(1),\n  kind: z.enum([\"component\", \"hook\", \"utility\", \"type\", \"style\"]).default(\"component\"),\n  path: registryFilePathSchema.optional(),\n});\n\nexport const registryComponentSchema = z.object({\n  componentId: z.string().min(1),\n  publicRef: z.string().min(1),\n  name: z.string().min(1),\n  status: z.string().min(1).default(\"stable\"),\n  tier: z.enum([\"core\", \"composition\", \"utility\", \"custom\"]).default(\"core\"),\n  category: z.string().optional(),\n  files: z.array(registryFileSchema).min(1),\n  styleFiles: z.array(registryFilePathSchema).default([]),\n  tokenDependencies: z.array(z.string().min(1)).default([]),\n  runtimeDependencies: z.array(registryDependencySchema).default([]),\n  peerDependencies: z.array(registryDependencySchema).default([]),\n  internalDependencies: z.array(z.string().min(1)).default([]),\n  exports: z.array(registryComponentExportSchema).default([]),\n  contract: z.unknown().optional(),\n  examples: z.array(z.unknown()).default([]),\n  provenance: z.record(z.unknown()).default({}),\n});\n\nexport const registryEntrypointSchema = z.object({\n  specifier: z.string().min(1),\n  sourcePath: registryFilePathSchema,\n});\n\nexport const registryInstallProfileSchema = z.object({\n  name: z.string().min(1),\n  targetPath: registryPathSchema,\n  importPath: z.string().min(1),\n  stylePath: registryPathSchema.optional(),\n  includeTests: z.boolean().default(false),\n});\n\nconst registryManifestBaseSchema = z.object({\n  schemaVersion: z.literal(REGISTRY_MANIFEST_SCHEMA_VERSION),\n  registryId: z.string().min(1),\n  name: z.string().min(1),\n  channel: z.string().min(1),\n  version: z.string().min(1),\n  contractVersionId: z.string().optional(),\n  fcid: sha256Schema.optional(),\n  generatedAt: z.string().datetime(),\n  source: registrySourceSchema,\n  packageFiles: z.array(registryFileSchema).default([]),\n  entrypoints: z.array(registryEntrypointSchema).default([]),\n  components: z.record(z.string(), registryComponentSchema),\n  dependencies: z.array(registryDependencySchema).default([]),\n  installProfiles: z.array(registryInstallProfileSchema).default([]),\n});\n\nexport const registryManifestDraftSchema = registryManifestBaseSchema;\n\nexport const registryManifestSchema = registryManifestBaseSchema.extend({\n  registryHash: sha256Schema,\n});\n\nexport const registryArtifactSchema = z\n  .object({\n    schemaVersion: z.literal(REGISTRY_ARTIFACT_SCHEMA_VERSION),\n    manifest: registryManifestSchema,\n    files: z.record(registryFilePathSchema, registryFileContentSchema),\n  })\n  .superRefine((artifact, ctx) => {\n    const filesByPath = artifact.files;\n    for (const [path, content] of Object.entries(filesByPath)) {\n      if (content.path !== path) {\n        ctx.addIssue({\n          code: z.ZodIssueCode.custom,\n          path: [\"files\", path, \"path\"],\n          message: `Registry file map key ${path} does not match content path ${content.path}`,\n        });\n      }\n    }\n\n    const manifestFiles = [\n      ...artifact.manifest.packageFiles,\n      ...artifact.manifest.entrypoints.map((entrypoint) => ({\n        path: entrypoint.sourcePath,\n        role: \"barrel\" as const,\n        sha256: filesByPath[entrypoint.sourcePath]?.sha256 ?? \"\",\n        size: filesByPath[entrypoint.sourcePath]?.size ?? 0,\n        contentType: filesByPath[entrypoint.sourcePath]?.contentType ?? \"text/plain\",\n        contentRef: `sha256:${filesByPath[entrypoint.sourcePath]?.sha256 ?? \"\"}`,\n      })),\n      ...Object.values(artifact.manifest.components).flatMap((component) => component.files),\n    ];\n\n    for (const file of manifestFiles) {\n      const content = filesByPath[file.path];\n      if (!content) {\n        ctx.addIssue({\n          code: z.ZodIssueCode.custom,\n          path: [\"files\", file.path],\n          message: `Missing content for registry file ${file.path}`,\n        });\n        continue;\n      }\n      if (content.sha256 !== file.sha256) {\n        ctx.addIssue({\n          code: z.ZodIssueCode.custom,\n          path: [\"files\", file.path, \"sha256\"],\n          message: `Content hash for ${file.path} does not match manifest`,\n        });\n      }\n      if (content.size !== file.size) {\n        ctx.addIssue({\n          code: z.ZodIssueCode.custom,\n          path: [\"files\", file.path, \"size\"],\n          message: `Content size for ${file.path} does not match manifest`,\n        });\n      }\n    }\n  });\n\nexport const registryInstallReceiptFileSchema = z.object({\n  path: registryFilePathSchema,\n  sha256: sha256Schema,\n  sourcePath: registryFilePathSchema,\n  componentId: z.string().min(1).optional(),\n});\n\nexport const registryInstallReceiptComponentSchema = z.object({\n  componentId: z.string().min(1),\n  publicRef: z.string().min(1),\n  name: z.string().min(1),\n  files: z.array(registryFilePathSchema),\n});\n\nexport const registryInstallReceiptSchema = z.object({\n  schemaVersion: z.literal(REGISTRY_INSTALL_RECEIPT_SCHEMA_VERSION),\n  registryId: z.string().min(1),\n  registryVersion: z.string().min(1),\n  registryHash: sha256Schema,\n  fcid: sha256Schema.optional(),\n  channel: z.string().min(1).optional(),\n  targetPath: registryPathSchema,\n  importPath: z.string().min(1),\n  installedComponents: z.array(registryInstallReceiptComponentSchema),\n  files: z.array(registryInstallReceiptFileSchema),\n  dependencies: z.array(registryDependencySchema).default([]),\n  installedAt: z.string().datetime(),\n});\n\nexport type RegistryDependencyType = z.infer<typeof registryDependencyTypeSchema>;\nexport type RegistryDependency = z.infer<typeof registryDependencySchema>;\nexport type RegistryFileRole = z.infer<typeof registryFileRoleSchema>;\nexport type RegistryFile = z.infer<typeof registryFileSchema>;\nexport type RegistryFileContent = z.infer<typeof registryFileContentSchema>;\nexport type RegistrySource = z.infer<typeof registrySourceSchema>;\nexport type RegistryComponentExport = z.infer<typeof registryComponentExportSchema>;\nexport type RegistryComponent = z.infer<typeof registryComponentSchema>;\nexport type RegistryEntrypoint = z.infer<typeof registryEntrypointSchema>;\nexport type RegistryInstallProfile = z.infer<typeof registryInstallProfileSchema>;\nexport type RegistryManifestDraft = z.input<typeof registryManifestDraftSchema>;\nexport type RegistryManifest = z.infer<typeof registryManifestSchema>;\nexport type RegistryArtifact = z.infer<typeof registryArtifactSchema>;\nexport type RegistryInstallReceiptFile = z.infer<typeof registryInstallReceiptFileSchema>;\nexport type RegistryInstallReceiptComponent = z.infer<typeof registryInstallReceiptComponentSchema>;\nexport type RegistryInstallReceipt = z.infer<typeof registryInstallReceiptSchema>;\n\nexport interface RegistryFileInput {\n  path: string;\n  role: RegistryFileRole;\n  content: string;\n  contentType: string;\n  contentRef?: string;\n}\n\nexport interface RegistryArtifactInput {\n  manifest: RegistryManifestDraft;\n  files: readonly RegistryFileContent[];\n}\n\nfunction registryHashPayload(manifest: RegistryManifestDraft | RegistryManifest): unknown {\n  const { generatedAt: _generatedAt, ...withoutGeneratedAt } = manifest;\n  if (\"registryHash\" in withoutGeneratedAt) {\n    const { registryHash: _registryHash, ...withoutHash } = withoutGeneratedAt;\n    return withoutHash;\n  }\n  return withoutGeneratedAt;\n}\n\nexport function computeRegistryHash(manifest: RegistryManifestDraft | RegistryManifest): string {\n  return contractHash(registryHashPayload(manifest));\n}\n\nexport function finalizeRegistryManifest(input: RegistryManifestDraft): RegistryManifest {\n  const draft = registryManifestDraftSchema.parse(input);\n  return registryManifestSchema.parse({\n    ...draft,\n    registryHash: computeRegistryHash(draft),\n  });\n}\n\nexport function hashRegistryFileContent(content: string): string {\n  return sha256Hex(content);\n}\n\nexport function registryFileSize(content: string): number {\n  return new TextEncoder().encode(content).length;\n}\n\nexport function buildRegistryFile(input: RegistryFileInput): {\n  metadata: RegistryFile;\n  content: RegistryFileContent;\n} {\n  const sha256 = hashRegistryFileContent(input.content);\n  const size = registryFileSize(input.content);\n  const path = registryFilePathSchema.parse(input.path);\n  const contentType = z.string().min(1).parse(input.contentType);\n  return {\n    metadata: registryFileSchema.parse({\n      path,\n      role: input.role,\n      sha256,\n      size,\n      contentType,\n      contentRef: input.contentRef ?? `sha256:${sha256}`,\n    }),\n    content: registryFileContentSchema.parse({\n      path,\n      content: input.content,\n      sha256,\n      size,\n      contentType,\n    }),\n  };\n}\n\nexport function buildRegistryArtifact(input: RegistryArtifactInput): RegistryArtifact {\n  const manifest = finalizeRegistryManifest(input.manifest);\n  const files = new Map<string, RegistryFileContent>();\n  for (const file of input.files) {\n    const content = registryFileContentSchema.parse(file);\n    if (files.has(content.path)) {\n      throw new Error(`Duplicate registry file content for ${content.path}`);\n    }\n    files.set(content.path, content);\n  }\n\n  return registryArtifactSchema.parse({\n    schemaVersion: REGISTRY_ARTIFACT_SCHEMA_VERSION,\n    manifest,\n    files: Object.fromEntries(files),\n  });\n}\n\nexport function assertValidRegistryArtifact(artifact: unknown): RegistryArtifact {\n  return registryArtifactSchema.parse(artifact);\n}\n\nexport function registryArtifactDigest(artifact: RegistryArtifact): string {\n  const files = Object.fromEntries(\n    Object.entries(artifact.files)\n      .map(([path, file]) => [path, { sha256: file.sha256, size: file.size }] as const)\n      .sort(([leftPath], [rightPath]) => leftPath.localeCompare(rightPath))\n  );\n\n  return contractHash({\n    schemaVersion: artifact.schemaVersion,\n    manifest: registryHashPayload(artifact.manifest),\n    files,\n  });\n}\n\nexport function registryManifestCanonicalPreimage(\n  manifest: RegistryManifestDraft | RegistryManifest\n): string {\n  return canonicalPreimage(registryHashPayload(manifest));\n}\n","/**\n * Frontend Contract hashing — the cross-runtime content-address (FCID).\n *\n * The keystone trust property of the Frontend Contract is that \"what the agent\n * was served\" and \"what CI enforced\" are provably the same bytes. That only\n * holds if the contract hash is computed by an *identical* function in every\n * runtime that touches it: the CLI (Node), the Convex isolate, and the browser.\n *\n * The fact-IR `hash64Hex` (FNV-1a, in `../facts/ids.ts`) is deliberately NOT\n * used here: it is a 64-bit non-cryptographic integrity reference for in-process\n * fact dedup, and Convex independently reaches for `crypto.subtle` (async, and a\n * *different* algorithm). Two different hashes over the same preimage cannot back\n * a \"same 64 hex chars or the build is rejected\" guarantee.\n *\n * So this module ships ONE function: a synchronous, dependency-free SHA-256 over\n * a number-normalizing canonical preimage. Synchronous so it composes with the\n * sync fact-compilation path; dependency-free so it is byte-identical across\n * Node, the Convex isolate, and the browser without a native/optional dep\n * (`crypto.subtle` is async; `@noble/hashes` is not a dependency of this MIT,\n * browser-safe package). `TextEncoder` is the only ambient global used, and it is\n * present in all three runtimes.\n */\n\n// ---------------------------------------------------------------------------\n// Canonical preimage\n// ---------------------------------------------------------------------------\n\n/**\n * Normalize a number to a stable string. `JSON.stringify` is stable for finite\n * numbers, but renders `NaN`/`Infinity` as `null` (ambiguous) and does not\n * collapse `-0`. Token values flow into the contract body, so a serializer that\n * silently maps `NaN` to `null` would hash two different inputs to the same\n * preimage. Non-finite numbers get unambiguous sentinels instead; `-0` collapses\n * to `0`. This is total (never throws) because it runs on the ingest hot path.\n */\nfunction normalizeNumber(value: number): string {\n  if (Number.isNaN(value)) return '\"@num:nan\"';\n  if (value === Infinity) return '\"@num:+inf\"';\n  if (value === -Infinity) return '\"@num:-inf\"';\n  if (Object.is(value, -0)) return \"0\";\n  return JSON.stringify(value);\n}\n\n/**\n * Deterministic, canonical serialization of a contract body for hashing.\n *\n * - object keys sorted lexicographically; attribute order is irrelevant\n * - `undefined` properties dropped (so optional fields don't perturb the hash)\n * - numbers normalized via {@link normalizeNumber}\n * - `bigint` encoded as its decimal string (JSON cannot represent it natively)\n *\n * This is intentionally a separate serializer from `facts/ids.ts#canonicalJson`:\n * that one targets in-process fact IDs and does not normalize numbers, and we\n * must not change its output (it would silently re-key existing fact IDs).\n */\nexport function canonicalPreimage(value: unknown): string {\n  if (value === undefined || value === null) return \"null\";\n  const type = typeof value;\n  if (type === \"number\") return normalizeNumber(value as number);\n  if (type === \"string\" || type === \"boolean\") return JSON.stringify(value);\n  if (type === \"bigint\") return JSON.stringify((value as bigint).toString());\n  if (Array.isArray(value)) {\n    return `[${value.map(canonicalPreimage).join(\",\")}]`;\n  }\n  if (type !== \"object\") {\n    // functions, symbols — not valid contract content; encode as null so the\n    // serializer stays total rather than throwing on the ingest path.\n    return \"null\";\n  }\n  const entries = Object.entries(value as Record<string, unknown>)\n    .filter(([, v]) => v !== undefined)\n    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));\n  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalPreimage(v)}`).join(\",\")}}`;\n}\n\n// ---------------------------------------------------------------------------\n// SHA-256 (FIPS 180-4), synchronous, pure JS\n// ---------------------------------------------------------------------------\n\n// First 32 bits of the fractional parts of the cube roots of the first 64 primes.\nconst K = new Uint32Array([\n  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,\n]);\n\nfunction rotr(value: number, bits: number): number {\n  return ((value >>> bits) | (value << (32 - bits))) >>> 0;\n}\n\n/**\n * SHA-256 of a UTF-8 string, returned as 64 lowercase hex chars.\n *\n * Deterministic and synchronous in every runtime. Verified against the FIPS\n * 180-4 vectors in `hash.test.ts`.\n */\nexport function sha256Hex(message: string): string {\n  const bytes = new TextEncoder().encode(message);\n  const length = bytes.length;\n  const bitLength = length * 8;\n\n  // Padding: append 0x80, then zeros, then the 64-bit big-endian bit length,\n  // so the total is a multiple of 64 bytes.\n  const withMarker = length + 1;\n  const zeroPad = (56 - (withMarker % 64) + 64) % 64;\n  const total = withMarker + zeroPad + 8;\n  const buffer = new Uint8Array(total);\n  buffer.set(bytes, 0);\n  buffer[length] = 0x80;\n\n  const view = new DataView(buffer.buffer);\n  // 64-bit length: high word then low word, big-endian. bitLength can exceed\n  // 2^32 for very large inputs, so split rather than truncate.\n  view.setUint32(total - 8, Math.floor(bitLength / 0x100000000));\n  view.setUint32(total - 4, bitLength >>> 0);\n\n  let h0 = 0x6a09e667;\n  let h1 = 0xbb67ae85;\n  let h2 = 0x3c6ef372;\n  let h3 = 0xa54ff53a;\n  let h4 = 0x510e527f;\n  let h5 = 0x9b05688c;\n  let h6 = 0x1f83d9ab;\n  let h7 = 0x5be0cd19;\n\n  const w = new Uint32Array(64);\n  for (let chunk = 0; chunk < total; chunk += 64) {\n    for (let t = 0; t < 16; t++) w[t] = view.getUint32(chunk + t * 4);\n    for (let t = 16; t < 64; t++) {\n      const w15 = w[t - 15];\n      const w2 = w[t - 2];\n      const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ (w15 >>> 3);\n      const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ (w2 >>> 10);\n      w[t] = (w[t - 16] + s0 + w[t - 7] + s1) >>> 0;\n    }\n\n    let a = h0;\n    let b = h1;\n    let c = h2;\n    let d = h3;\n    let e = h4;\n    let f = h5;\n    let g = h6;\n    let h = h7;\n\n    for (let t = 0; t < 64; t++) {\n      const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);\n      const ch = (e & f) ^ (~e & g);\n      const temp1 = (h + s1 + ch + K[t] + w[t]) >>> 0;\n      const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);\n      const maj = (a & b) ^ (a & c) ^ (b & c);\n      const temp2 = (s0 + maj) >>> 0;\n      h = g;\n      g = f;\n      f = e;\n      e = (d + temp1) >>> 0;\n      d = c;\n      c = b;\n      b = a;\n      a = (temp1 + temp2) >>> 0;\n    }\n\n    h0 = (h0 + a) >>> 0;\n    h1 = (h1 + b) >>> 0;\n    h2 = (h2 + c) >>> 0;\n    h3 = (h3 + d) >>> 0;\n    h4 = (h4 + e) >>> 0;\n    h5 = (h5 + f) >>> 0;\n    h6 = (h6 + g) >>> 0;\n    h7 = (h7 + h) >>> 0;\n  }\n\n  return [h0, h1, h2, h3, h4, h5, h6, h7]\n    .map((value) => value.toString(16).padStart(8, \"0\"))\n    .join(\"\");\n}\n\n// ---------------------------------------------------------------------------\n// Contract hash (FCID)\n// ---------------------------------------------------------------------------\n\n/**\n * The Frontend Contract ID: `sha256(canonicalPreimage(body))`, 64 lowercase hex\n * chars. Identical inputs produce an identical FCID in the CLI, the Convex\n * isolate, and the browser — which is what lets the gen-time agent view and the\n * CI enforcement reference the same contract by hash.\n */\nexport function contractHash(body: unknown): string {\n  return sha256Hex(canonicalPreimage(body));\n}\n"],"mappings":"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","names":[]}

package/dist/codes/index.d.ts

@@ -0,0 +1,40 @@
+import { Severity } from '../severity.js';
+import { Violation, Finding } from '../schemas/index.js';
+import 'zod';
+
+declare const EXPLAIN_URL_BASE = "https://usefragments.com/errors/";
+type CodeCategory = "canonical-usage" | "tokens" | "a11y" | "states" | "composition" | "props" | "performance" | "safety" | "system";
+type CodeLifecycle = "experimental" | "stable" | "deprecated";
+interface FuiCode {
+    code: string;
+    ruleId: string;
+    category: CodeCategory;
+    defaultSeverity: Severity;
+    title: string;
+    explainUrl: string;
+    lifecycle: CodeLifecycle;
+    replacedBy?: string;
+    fixAvailable: boolean;
+    evidenceRequired: boolean;
+}
+declare const CODES: readonly [FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode, FuiCode];
+declare const byCode: ReadonlyMap<string, FuiCode>;
+declare const byRuleId: ReadonlyMap<string, FuiCode>;
+declare function explainUrlForCode(code: string): string;
+
+interface BridgeViolationInput {
+    violation: Violation;
+    canonicalRuleId?: string;
+    validator?: string;
+    attributes?: Record<string, unknown>;
+}
+declare function bridgeSourceViolation(input: BridgeViolationInput): {
+    violation: Violation;
+    finding: Finding;
+};
+declare function bridgeSourceViolations(violations: Violation[], options?: Omit<BridgeViolationInput, "violation">): {
+    violations: Violation[];
+    findings: Finding[];
+};
+
+export { type BridgeViolationInput, CODES, type CodeCategory, type CodeLifecycle, EXPLAIN_URL_BASE, type FuiCode, Severity, bridgeSourceViolation, bridgeSourceViolations, byCode, byRuleId, explainUrlForCode };

package/dist/codes/index.js

@@ -0,0 +1,23 @@
+import {
+  CODES,
+  EXPLAIN_URL_BASE,
+  bridgeSourceViolation,
+  bridgeSourceViolations,
+  byCode,
+  byRuleId,
+  explainUrlForCode
+} from "../chunk-243QYRUF.js";
+import "../chunk-R3X7UBHU.js";
+import "../chunk-JNBFJ34I.js";
+import "../chunk-EIYNNS77.js";
+import "../chunk-V4VQB57N.js";
+export {
+  CODES,
+  EXPLAIN_URL_BASE,
+  bridgeSourceViolation,
+  bridgeSourceViolations,
+  byCode,
+  byRuleId,
+  explainUrlForCode
+};
+//# sourceMappingURL=index.js.map

package/dist/codes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/compiled-types/index.d.ts

@@ -0,0 +1,5 @@
+import '../types-xJ2xyp_G.js';
+export { aV as AIMetadata, C as CompiledBlock, b as CompiledFragment, y as CompiledFragmentsFile, D as CompiledTokenData, E as CompiledTokenEntry, aW as ComponentRelation, aX as FragmentContract, aY as FragmentGenerated, aZ as FragmentMeta, a_ as FragmentUsage, a$ as ImportEntry, af as ObservedComponentUsage, ag as ObservedUsageProp, b0 as PerformanceData, b1 as PerformanceSummary, b2 as PropDefinition, b3 as Theme, b4 as VerifyResult } from '../governance-BOa3KyiJ.js';
+import 'zod';
+import 'react';
+import '../topology/index.js';

package/dist/compiled-types/index.js

@@ -0,0 +1 @@
+//# sourceMappingURL=index.js.map

package/dist/compiled-types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}