@zaip-ai/cli 6.2.0 → 7.5.0

package/templates/.agents/design/design-system-maker/runtime/collection.mjs

@@ -0,0 +1,269 @@
+import { randomUUID } from "node:crypto";
+import { realpath } from "node:fs/promises";
+import { artifactNames, entry, job, seal, unseal } from "./contracts.mjs";
+import { assignDesignCodes } from "./design-codes.mjs";
+import {
+  bytes,
+  directory,
+  hash,
+  identifier,
+  json,
+  names,
+  optional,
+  read,
+  remove,
+  write,
+} from "./io.mjs";
+import { acquire } from "./lock.mjs";
+import { trashStore } from "./trash.mjs";
+
+export const revisionPath = (id, revision) =>
+  `entries/${identifier(id)}/revisions/r-${String(revision).padStart(6, "0")}`;
+export async function openCollection(workspace, checkpoint = async () => {}) {
+  const workspaceRoot = await realpath(workspace);
+  const root = await directory(workspaceRoot, ".agents/design/design-system-maker/data");
+  const release = await acquire(await realpath(root));
+  const identity = hash(
+    Buffer.from(process.platform === "win32" ? workspaceRoot.toLowerCase() : workspaceRoot),
+  );
+  const marker = {
+    schema_version: 1,
+    workspace_hash: identity,
+    owner: "project",
+    migration: "explicit-only",
+  };
+  try {
+    const bound = await json(root, "collection.json");
+    if (bound && JSON.stringify(bound) !== JSON.stringify(marker))
+      throw new Error("Collection namespace/future schema mismatch; preserve data");
+    if (!bound) await write(root, "collection.json", bytes(marker), true);
+    if ((await optional(root, ".gitignore")) === null)
+      await write(root, ".gitignore", Buffer.from("*\n!.gitignore\n"), true);
+    await directory(root, "entries");
+    await directory(root, "jobs");
+    let indexCache = [];
+    let trashCache = new Map();
+    let designCodes = new Map();
+    async function version(id, revision, verifyArtifacts = false) {
+      const folder = revisionPath(id, revision);
+      const value = entry(await json(root, `${folder}/entry.json`));
+      if (value.id !== id || value.revision !== revision)
+        throw new Error("Version identity mismatch");
+      const receipt = unseal(await json(root, `${folder}/receipt.json`));
+      if (
+        receipt.id !== id ||
+        receipt.revision !== revision ||
+        receipt.workspace_hash !== identity ||
+        receipt.entry_hash !== hash(bytes(value))
+      )
+        throw new Error("Version receipt does not match entry");
+      if (!bytes(receipt.artifact_inventory).equals(bytes(value.artifacts)))
+        throw new Error("Version receipt artifact inventory differs");
+      if (verifyArtifacts)
+        for (const artifact of value.artifacts) {
+          const content = await read(root, `${folder}/${artifact.name}`);
+          if (content.length !== artifact.bytes || hash(content) !== artifact.hash)
+            throw new Error("Collection artifact bytes corrupted");
+        }
+      return value;
+    }
+    async function get(id, revision = null) {
+      identifier(id);
+      const value = await json(root, `entries/${id}/state.json`);
+      if (value === null) return null;
+      entry(value);
+      const verified = await version(id, revision ?? value.revision);
+      if (revision === null && !bytes(value).equals(bytes(verified)))
+        throw new Error("Latest state differs from immutable revision");
+      return verified;
+    }
+    async function rebuild() {
+      const values = [];
+      const nextTrash = new Map();
+      for (const item of await names(root, "entries")) {
+        if (!item.isDirectory()) throw new Error("Unexpected entry directory content");
+        identifier(item.name);
+        const value = await get(item.name);
+        if (value) {
+          values.push(value);
+          nextTrash.set(item.name, await trash.status(item.name));
+        }
+      }
+      values.sort((a, b) => b.updated_at.localeCompare(a.updated_at) || a.id.localeCompare(b.id));
+      designCodes = await assignDesignCodes(root, identity, values);
+      await write(
+        root,
+        "index.json",
+        bytes({
+          schema_version: 1,
+          workspace_hash: identity,
+          rebuilt_at: new Date().toISOString(),
+          entries: values,
+        }),
+      );
+      indexCache = values;
+      trashCache = nextTrash;
+      return values;
+    }
+    const trash = trashStore(root, identity, get, checkpoint);
+    async function apply(journal) {
+      const plan = unseal(journal);
+      entry(plan.next);
+      if (
+        plan.workspace_hash !== identity ||
+        !Array.isArray(plan.files) ||
+        plan.files.length > artifactNames.length + 2
+      )
+        throw new Error("Journal namespace/inventory invalid");
+      identifier(plan.tx_id);
+      const current = await json(root, `entries/${plan.next.id}/state.json`);
+      if (
+        (current === null && plan.base_revision !== 0) ||
+        (current && ![plan.base_revision, plan.next.revision].includes(current.revision))
+      )
+        throw new Error("Collection journal revision conflict");
+      const folder = revisionPath(plan.next.id, plan.next.revision);
+      const stages = [];
+      for (const [index, row] of plan.files.entries()) {
+        if (![...artifactNames, "entry.json", "receipt.json"].includes(row.name))
+          throw new Error("Journal file outside revision contract");
+        const content = await read(root, `transactions/${plan.tx_id}/${index}.bin`);
+        if (content.length !== row.bytes || hash(content) !== row.hash)
+          throw new Error("Collection stage checksum mismatch");
+        const previous = await optional(root, `${folder}/${row.name}`);
+        if (previous !== null && hash(previous) !== row.hash)
+          throw new Error("Revision artifact changed outside writer");
+        stages.push({ row, content });
+      }
+      for (const { row, content } of stages)
+        await write(root, `${folder}/${row.name}`, content, true);
+      await version(plan.next.id, plan.next.revision, true);
+      await checkpoint("before-state");
+      await write(root, `entries/${plan.next.id}/state.json`, bytes(plan.next));
+      await checkpoint("after-state");
+      await rebuild();
+      await checkpoint("after-index");
+      await remove(root, "journal.json");
+      return plan.next;
+    }
+    async function recover() {
+      const pending = await json(root, "journal.json");
+      if (pending) await apply(pending);
+    }
+    async function commit(value, expectedRevision, artifacts = {}) {
+      await recover();
+      entry(value);
+      const current = await get(value.id);
+      if ((current?.revision ?? 0) !== expectedRevision || value.revision !== expectedRevision + 1)
+        throw new Error("Collection revision conflict");
+      const tx_id = `tx-${randomUUID()}`;
+      const files = {
+        ...artifacts,
+        "entry.json": bytes(value),
+        "receipt.json": bytes(
+          seal({
+            schema_version: 1,
+            id: value.id,
+            revision: value.revision,
+            workspace_hash: identity,
+            entry_hash: hash(bytes(value)),
+            artifact_inventory: value.artifacts,
+            committed_at: new Date().toISOString(),
+          }),
+        ),
+      };
+      const rows = [];
+      await checkpoint("before-stage");
+      for (const [index, [name, content]] of Object.entries(files).entries()) {
+        await write(root, `transactions/${tx_id}/${index}.bin`, content, true);
+        rows.push({ name, bytes: content.length, hash: hash(content) });
+      }
+      await checkpoint("after-stage");
+      const journal = seal({
+        schema_version: 1,
+        workspace_hash: identity,
+        tx_id,
+        base_revision: expectedRevision,
+        next: value,
+        files: rows,
+      });
+      await write(root, "journal.json", bytes(journal), true);
+      await checkpoint("after-journal");
+      return apply(journal);
+    }
+    async function readJob(id) {
+      identifier(id);
+      const value = await json(root, `jobs/${id}.json`);
+      return value === null ? null : job(value);
+    }
+    async function writeJob(value) {
+      job(value);
+      await write(root, `jobs/${value.id}.json`, bytes(value));
+      return value;
+    }
+    async function allJobs() {
+      const result = [];
+      for (const item of await names(root, "jobs")) {
+        if (item.isFile() && /^_stage-[a-f0-9-]{36}$/.test(item.name)) continue;
+        if (!item.isFile() || !/\.json$/.test(item.name))
+          throw new Error("Unexpected jobs namespace content");
+        result.push(await readJob(item.name.slice(0, -5)));
+      }
+      return result;
+    }
+    async function artifact(id, revision, name) {
+      const value = await get(id, revision);
+      const metadata = value?.artifacts.find((item) => item.name === name);
+      if (!metadata) throw new Error("Unknown revision artifact");
+      const content = await read(root, `${revisionPath(id, revision)}/${name}`);
+      if (content.length !== metadata.bytes || hash(content) !== metadata.hash)
+        throw new Error("Collection artifact bytes corrupted");
+      return content;
+    }
+    await recover();
+    await rebuild();
+    return {
+      root,
+      workspace: workspaceRoot,
+      identity,
+      get,
+      version,
+      rebuild,
+      designCode: (id) => designCodes.get(id) ?? null,
+      list: (offset = 0, limit = 100, trashed = false) => {
+        const values = indexCache.filter(
+          (value) => (trashCache.get(value.id)?.state === "trashed") === trashed,
+        );
+        return {
+          entries: structuredClone(
+            values.slice(offset, offset + limit).map((value) => ({
+              ...value,
+              design_code: designCodes.get(value.id),
+              trash_revision: trashCache.get(value.id)?.trash_revision ?? 0,
+              deleted_at:
+                trashCache.get(value.id)?.state === "trashed"
+                  ? trashCache.get(value.id).observed_at
+                  : null,
+            })),
+          ),
+          total: values.length,
+        };
+      },
+      trashStatus: trash.status,
+      async changeTrash(id, expectedRevision, expectedTrashRevision, state) {
+        const record = await trash.change(id, expectedRevision, expectedTrashRevision, state);
+        await rebuild();
+        return record;
+      },
+      commit,
+      readJob,
+      writeJob,
+      allJobs,
+      artifact,
+      close: release,
+    };
+  } catch (error) {
+    await release();
+    throw error;
+  }
+}

package/templates/.agents/design/design-system-maker/runtime/contracts.mjs

@@ -0,0 +1,383 @@
+import { validateFailure } from "../../../tools/visual-url/failure.mjs";
+import {
+  localDeclarationMethods,
+  localSourceTypes,
+  validateLocalSource,
+} from "../../../tools/visual-url/local-source.mjs";
+import {
+  defaults,
+  displayUrl,
+  evidenceLimits,
+  replayableUrl,
+  safeText,
+  timestamp,
+} from "../../../tools/visual-url/policy.mjs";
+import { validateVisualModel } from "../../../tools/visual-url/visual-model.mjs";
+import { bytes, hash, identifier } from "./io.mjs";
+import { browserTraffic } from "./request-contracts.mjs";
+
+export { safeText };
+export const states = ["collecting", "partial", "ready", "failed"];
+export const artifactNames = [
+  "proposal.json",
+  "handoff.json",
+  "DESIGN.md",
+  "screenshot.png",
+  "report.json",
+  "REPORT.md",
+  "favicon.png",
+  "favicon.jpg",
+  "favicon.ico",
+];
+export const jobPhases = [
+  "queued",
+  "fetch-html",
+  "parse-css",
+  "fetch-css",
+  "build-report",
+  "verify-artifacts",
+  "commit",
+  "completed",
+  "failed",
+  "browser-open",
+  "browser-wait",
+  "browser-capture",
+];
+function sanitized(value, maximum = 4096) {
+  if (safeText(value, maximum) !== value)
+    throw new Error("Collection text must already be sanitized");
+}
+function summary(value) {
+  const keys = [
+    "source",
+    "capabilities",
+    "uncertainty",
+    "swatches",
+    "observed_count",
+    "inferred_count",
+    "unknown_count",
+  ];
+  if (
+    !value ||
+    keys.some((key) => !Object.hasOwn(value, key)) ||
+    Object.keys(value).some((key) => ![...keys, "report", "visual_model"].includes(key))
+  )
+    throw new Error("Invalid/future proposal summary fields");
+  const sourceKeys = ["type", "url", "observed_at", "source_hash", "source_preserved"];
+  if (localSourceTypes.includes(value.source?.type)) {
+    validateLocalSource(value.source);
+  } else if (
+    !value.source ||
+    sourceKeys.some((key) => !Object.hasOwn(value.source, key)) ||
+    Object.keys(value.source).some(
+      (key) => ![...sourceKeys, "request_url", "final_url"].includes(key),
+    ) ||
+    value.source.type !== "url" ||
+    value.source.url !== displayUrl(value.source.url) ||
+    !/^[a-f0-9]{64}$/.test(value.source.source_hash) ||
+    value.source.source_preserved !== false
+  )
+    throw new Error("Invalid proposal summary source");
+  timestamp(value.source.observed_at);
+  for (const key of ["request_url", "final_url"])
+    if (value.source[key] !== undefined && replayableUrl(value.source[key]) !== value.source[key])
+      throw new Error("Invalid safe summary URL");
+  if (value.report !== undefined) {
+    const report = value.report;
+    if (
+      report?.method_version !== "css-evidence-v1" ||
+      report.score_kind !== "extraction-evidence-coverage" ||
+      !Number.isInteger(report.score) ||
+      report.score < 0 ||
+      report.score > 100 ||
+      !Array.isArray(report.metrics) ||
+      report.metrics.length !== 4 ||
+      !report.sampling ||
+      ![report.sampling.total, report.sampling.sampled, report.sampling.truncated].every(
+        (count) => Number.isSafeInteger(count) && count >= 0,
+      ) ||
+      report.sampling.sampled > defaults.declarations ||
+      report.sampling.sampled + report.sampling.truncated !== report.sampling.total
+    )
+      throw new Error("Invalid measured report summary");
+    for (const metric of report.metrics)
+      if (
+        !metric ||
+        ![metric.numerator, metric.denominator, metric.weight].every(
+          (count) => Number.isFinite(count) && count >= 0,
+        ) ||
+        metric.numerator > metric.denominator ||
+        !Number.isFinite(metric.ratio) ||
+        metric.ratio < 0 ||
+        metric.ratio > 1
+      )
+        throw new Error("Invalid measured metric");
+    if (
+      report.metrics.reduce((sum, metric) => sum + metric.weight, 0) !== 100 ||
+      report.score !==
+        Math.round(report.metrics.reduce((sum, metric) => sum + metric.weight * metric.ratio, 0))
+    )
+      throw new Error("Report score differs from measured formula");
+  }
+  validateVisualModel(value.visual_model);
+  const capabilityKeys = [
+    "static_reader",
+    "adapter_configured",
+    "host_capture_supplied",
+    "browser_resolved",
+    "screenshot_verified",
+    "runtime_rendered",
+  ];
+  if (
+    !value.capabilities ||
+    Object.keys(value.capabilities).sort().join() !== capabilityKeys.sort().join() ||
+    capabilityKeys.some((key) => typeof value.capabilities[key] !== "boolean") ||
+    value.capabilities.static_reader !== true ||
+    (value.capabilities.runtime_rendered &&
+      (!value.capabilities.browser_resolved || !value.capabilities.screenshot_verified)) ||
+    (value.capabilities.browser_resolved &&
+      !value.capabilities.host_capture_supplied &&
+      !value.capabilities.runtime_rendered) ||
+    (value.capabilities.screenshot_verified &&
+      !value.capabilities.host_capture_supplied &&
+      !value.capabilities.runtime_rendered)
+  )
+    throw new Error("Invalid proposal summary capabilities");
+  if (!Array.isArray(value.uncertainty) || value.uncertainty.length > 128)
+    throw new Error("Invalid uncertainty inventory");
+  for (const gap of value.uncertainty) sanitized(gap);
+  if (
+    !Array.isArray(value.swatches) ||
+    value.swatches.length > 12 ||
+    value.swatches.some(
+      (item) =>
+        !item ||
+        Object.keys(item).sort().join() !== "evidence,kind,method,value" ||
+        !/^#[a-f0-9]{3,8}$/i.test(item.value) ||
+        item.kind !== "inferred" ||
+        (item.method !== "static-css-declaration" &&
+          !(
+            localSourceTypes.includes(value.source.type) &&
+            localDeclarationMethods.includes(item.method)
+          )) ||
+        !Array.isArray(item.evidence) ||
+        !item.evidence.length ||
+        item.evidence.length > 16 ||
+        item.evidence.some((id) => !/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,95}$/.test(id)),
+    )
+  )
+    throw new Error("Invalid bounded inferred swatches");
+  for (const key of ["observed_count", "inferred_count", "unknown_count"])
+    if (!Number.isInteger(value[key]) || value[key] < 0 || value[key] > evidenceLimits.observations)
+      throw new Error("Invalid summary evidence counts");
+}
+export function entry(value) {
+  const keys = [
+    "schema_version",
+    "id",
+    "slug",
+    "name",
+    "url",
+    "status",
+    "revision",
+    "created_at",
+    "updated_at",
+    "job_id",
+    "artifacts",
+    "proposal_summary",
+    "error",
+  ];
+  if (
+    !value ||
+    keys.some((key) => !Object.hasOwn(value, key)) ||
+    Object.keys(value).some(
+      (key) => ![...keys, "request_url", "failure", "source", "request_hash"].includes(key),
+    ) ||
+    value.schema_version !== 1 ||
+    !states.includes(value.status) ||
+    !Number.isInteger(value.revision) ||
+    value.revision < 1
+  )
+    throw new Error("Invalid/future collection entry schema");
+  identifier(value.id);
+  identifier(value.slug);
+  identifier(value.job_id);
+  if (value.request_hash !== undefined && !/^[a-f\d]{64}$/.test(value.request_hash))
+    throw new Error("Invalid entry request hash");
+  sanitized(value.name, 128);
+  timestamp(value.created_at);
+  timestamp(value.updated_at);
+  if (
+    (value.url === null
+      ? !localSourceTypes.includes(value.source?.type)
+      : value.url !== displayUrl(value.url)) ||
+    !Array.isArray(value.artifacts) ||
+    value.artifacts.length > artifactNames.length
+  )
+    throw new Error("Collection entry source/artifacts invalid");
+  if (value.source !== undefined) validateLocalSource(value.source);
+  if (value.request_url !== undefined && replayableUrl(value.request_url) !== value.request_url)
+    throw new Error("Collection replay URL must be exact and safe");
+  const seenArtifacts = new Set();
+  for (const artifact of value.artifacts) {
+    if (
+      !artifact ||
+      Object.keys(artifact).sort().join() !== "bytes,hash,name" ||
+      seenArtifacts.has(artifact.name) ||
+      !artifactNames.includes(artifact.name) ||
+      !/^[a-f0-9]{64}$/.test(artifact.hash) ||
+      !Number.isInteger(artifact.bytes) ||
+      artifact.bytes < 0 ||
+      artifact.bytes > 8388608
+    )
+      throw new Error("Collection artifact metadata invalid");
+    seenArtifacts.add(artifact.name);
+  }
+  if (
+    ["partial", "ready"].includes(value.status) &&
+    (!value.proposal_summary ||
+      !["proposal.json", "handoff.json", "DESIGN.md"].every((name) =>
+        value.artifacts.some((item) => item.name === name),
+      ))
+  )
+    throw new Error("Completed extraction artifact inventory missing");
+  if (value.proposal_summary !== null) summary(value.proposal_summary);
+  if (
+    value.proposal_summary?.report &&
+    !["report.json", "REPORT.md"].every((name) =>
+      value.artifacts.some((item) => item.name === name),
+    )
+  )
+    throw new Error("Measured report artifacts missing");
+  if (
+    ["collecting", "failed"].includes(value.status) &&
+    (value.proposal_summary !== null || value.artifacts.length !== 0)
+  )
+    throw new Error("Incomplete/failed entry cannot claim extraction artifacts");
+  if (value.error !== null) sanitized(value.error, 512);
+  if (value.failure !== undefined && value.failure !== null) {
+    validateFailure(value.failure);
+    if (value.status !== "failed") throw new Error("Failure metadata requires failed entry");
+  }
+  return value;
+}
+export function job(value) {
+  const keys = [
+    "schema_version",
+    "id",
+    "entry_id",
+    "status",
+    "created_at",
+    "updated_at",
+    "result_revision",
+    "error",
+  ];
+  if (
+    !value ||
+    keys.some((key) => !Object.hasOwn(value, key)) ||
+    Object.keys(value).some(
+      (key) =>
+        ![
+          ...keys,
+          "phase",
+          "started_at",
+          "completed_at",
+          "duration_ms",
+          "progress",
+          "events",
+          "failure",
+          "mode",
+          "browser",
+          "request_hash",
+        ].includes(key),
+    ) ||
+    value.schema_version !== 1 ||
+    !["queued", "running", "completed", "failed"].includes(value.status)
+  )
+    throw new Error("Invalid/future job schema");
+  if (value.request_hash !== undefined && !/^[a-f\d]{64}$/.test(value.request_hash))
+    throw new Error("Invalid job request hash");
+  identifier(value.id);
+  identifier(value.entry_id);
+  if (value.mode !== undefined && !["http", "browser"].includes(value.mode))
+    throw new Error("Invalid job mode");
+  if (value.browser !== undefined) {
+    if (
+      value.mode !== "browser" ||
+      !value.browser ||
+      !["action,deadline_at,state", "action,deadline_at,state,traffic"].includes(
+        Object.keys(value.browser).sort().join(),
+      ) ||
+      !["opening", "waiting-human", "capturing", "closed", "unavailable"].includes(
+        value.browser.state,
+      ) ||
+      (value.browser.deadline_at !== null &&
+        !Number.isFinite(Date.parse(value.browser.deadline_at))) ||
+      (value.browser.action !== null &&
+        safeText(value.browser.action, 128) !== value.browser.action)
+    )
+      throw new Error("Invalid browser job state");
+    if (value.browser.traffic !== undefined) browserTraffic(value.browser.traffic);
+  }
+  timestamp(value.created_at);
+  timestamp(value.updated_at);
+  if (
+    value.result_revision !== null &&
+    (!Number.isInteger(value.result_revision) || value.result_revision < 1)
+  )
+    throw new Error("Invalid job result revision");
+  if (
+    (value.status === "completed" && (value.result_revision === null || value.error !== null)) ||
+    (value.status === "failed" && !value.error) ||
+    (["queued", "running"].includes(value.status) &&
+      (value.result_revision !== null || value.error !== null))
+  )
+    throw new Error("Job status/result/error mismatch");
+  if (value.error !== null) sanitized(value.error, 512);
+  if (value.failure !== undefined && value.failure !== null) {
+    validateFailure(value.failure);
+    if (value.status !== "failed") throw new Error("Failure metadata requires failed job");
+  }
+  if (value.phase !== undefined) {
+    if (
+      !jobPhases.includes(value.phase) ||
+      !Array.isArray(value.events) ||
+      value.events.length > 64 ||
+      !value.progress ||
+      value.progress.percent !== null ||
+      !Number.isInteger(value.progress.resources_received) ||
+      value.progress.resources_received < 0 ||
+      value.progress.resources_received > defaults.resources
+    )
+      throw new Error("Invalid measured job progress");
+    for (const time of [value.started_at, value.completed_at]) if (time !== null) timestamp(time);
+    if (
+      value.duration_ms !== null &&
+      (!Number.isSafeInteger(value.duration_ms) || value.duration_ms < 0)
+    )
+      throw new Error("Invalid measured duration");
+    for (const event of value.events) {
+      timestamp(event.at);
+      if (
+        !jobPhases.includes(event.phase) ||
+        !Number.isInteger(event.resources_received) ||
+        event.resources_received < 0 ||
+        event.resources_received > defaults.resources
+      )
+        throw new Error("Invalid measured job event");
+    }
+  }
+  return value;
+}
+
+export function seal(value) {
+  return { ...value, checksum: hash(bytes(value)) };
+}
+export function unseal(value) {
+  if (value?.schema_version !== 1) throw new Error("Unsupported collection receipt/journal schema");
+  const { checksum, ...body } = value;
+  if (checksum !== hash(bytes(body))) throw new Error("Collection checksum mismatch");
+  return body;
+}
+
+export { browserTraffic, generate, revisionRequest } from "./request-contracts.mjs";

package/templates/.agents/design/design-system-maker/runtime/design-codes.mjs

@@ -0,0 +1,46 @@
+import { seal, unseal } from "./contracts.mjs";
+import { bytes, identifier, json, write } from "./io.mjs";
+
+// Called only under the collection writer lock. Separate from immutable revisions.
+export async function assignDesignCodes(root, identity, entries) {
+  const saved = await json(root, "design-codes.json");
+  const registry = saved
+    ? unseal(saved)
+    : { schema_version: 1, workspace_hash: identity, codes: {} };
+  if (
+    registry.schema_version !== 1 ||
+    registry.workspace_hash !== identity ||
+    !registry.codes ||
+    typeof registry.codes !== "object" ||
+    Array.isArray(registry.codes)
+  )
+    throw new Error("Invalid design code registry; preserve existing identifiers");
+  const used = new Set();
+  let next = 1;
+  for (const [id, number] of Object.entries(registry.codes)) {
+    identifier(id);
+    if (!Number.isSafeInteger(number) || number < 1 || used.has(number))
+      throw new Error("Invalid or duplicate design code");
+    used.add(number);
+    next = Math.max(next, number + 1);
+  }
+  let changed = !saved;
+  for (const entry of [...entries].sort(
+    (a, b) => a.created_at.localeCompare(b.created_at) || a.id.localeCompare(b.id),
+  )) {
+    identifier(entry.id);
+    if (Object.hasOwn(registry.codes, entry.id)) continue;
+    if (!Number.isSafeInteger(next)) throw new Error("Design code sequence exhausted");
+    Object.defineProperty(registry.codes, entry.id, {
+      value: next++,
+      enumerable: true,
+      configurable: true,
+      writable: true,
+    });
+    changed = true;
+  }
+  if (changed) await write(root, "design-codes.json", bytes(seal(registry)));
+  return new Map(
+    Object.entries(registry.codes).map(([id, code]) => [id, String(code).padStart(3, "0")]),
+  );
+}