@zaip-ai/cli 6.3.0 → 7.6.0

package/templates/.agents/design/design-system-maker/runtime/local-artifacts.mjs

@@ -0,0 +1,228 @@
+import { design, validate } from "../../../tools/visual-url/proposal.mjs";
+import { buildReport, reportMarkdown } from "../../../tools/visual-url/report.mjs";
+import {
+  boundedVisualModel,
+  safeVisualValue,
+  visualModel,
+} from "../../../tools/visual-url/visual-model.mjs";
+import { bytes, hash } from "./io.mjs";
+
+export const facets = [
+  "colors",
+  "typography",
+  "spacing",
+  "radii",
+  "borders",
+  "shadows",
+  "components",
+];
+export const colorRoles = [
+  "background",
+  "foreground",
+  "primary",
+  "primary_foreground",
+  "secondary",
+  "muted",
+  "accent",
+  "border",
+  "card",
+  "card_foreground",
+];
+export const typographyProperties = {
+  body_family: "font-family",
+  heading_family: "font-family",
+  size: "font-size",
+  weight: "font-weight",
+  line_height: "line-height",
+  letter_spacing: "letter-spacing",
+};
+export function emptyModel() {
+  return visualModel({ observations: [], dom: [] }, { components: [], themes: [] });
+}
+export function localProposal(id, source) {
+  return {
+    schema_version: 1,
+    extraction_id: id,
+    revision: 1,
+    status: "partial",
+    central_promotion: false,
+    source,
+    capabilities: {
+      static_reader: true,
+      adapter_configured: false,
+      host_capture_supplied: false,
+      browser_resolved: false,
+      screenshot_verified: false,
+      runtime_rendered: false,
+    },
+    resources: [],
+    dom: [],
+    observations: [],
+    token_candidates: [],
+    assets: [],
+    screenshot: null,
+    limitations: [
+      "Fonte local analisada estaticamente; nenhum script/configuração executado e nenhuma captura renderizada realizada.",
+      "Papéis e valores normalizados são propostas inferidas; não promovem o design central.",
+      "Bytes originais não preservados; inventário com hashes e artefatos normalizados permanecem na revisão.",
+    ],
+  };
+}
+export function localToken(
+  proposal,
+  property,
+  value,
+  locator,
+  selector,
+  sourceHash,
+  method,
+  extra = {},
+) {
+  const normalized = safeVisualValue(property, value);
+  if (normalized === null) return null;
+  const id = `local-${proposal.observations.length}`;
+  const provenance = {
+    url: null,
+    locator,
+    selector,
+    viewport: null,
+    observed_at: proposal.source.observed_at,
+    source_hash: sourceHash,
+    method,
+    ...extra,
+  };
+  proposal.observations.push({
+    id,
+    kind: "observed",
+    subject: "Retained local declaration; not rendered style",
+    value: `${property}: ${normalized}`,
+    reason: null,
+    provenance,
+  });
+  proposal.token_candidates.push({
+    property,
+    value: normalized,
+    kind: "inferred",
+    reason: "Declaração lida; uso visual e papel global não comprovados",
+    evidence: [id],
+  });
+  return {
+    value: normalized,
+    property,
+    kind: "inferred",
+    evidence: [id],
+    provenance,
+    reason: "Papel proposto a partir de documento/faceta explícita; não observação renderizada",
+  };
+}
+export function finalizeModel(model, method) {
+  model.status =
+    Object.values(model.tokens.colors).some(Boolean) ||
+    Object.values(model.tokens.typography).some(Boolean) ||
+    model.components.length ||
+    facets.slice(2, 6).some((key) => model.tokens[key].length)
+      ? "inferred"
+      : "unavailable";
+  model.theme = { status: "unknown", active: null, declared: [] };
+  model.coverage = {
+    status: "incomplete",
+    method,
+    scanned: null,
+    sampled: null,
+    omitted: null,
+    readiness: null,
+    limitations: [
+      "Documento/facetas interpretados; pixels, interações, cascata, recursos e temas ativos não verificados.",
+    ],
+  };
+  model.unknown = [
+    ...Object.entries(model.tokens.colors)
+      .filter(([, v]) => !v)
+      .map(([key]) => `colors.${key}`),
+    ...Object.entries(model.tokens.typography)
+      .filter(([, v]) => !v)
+      .map(([key]) => `typography.${key}`),
+    "rendered.styles",
+    "rendered.resources",
+  ];
+  model.limitations = [
+    "Tokens locais inferidos com proveniência; nenhum CSS/HTML da fonte aplicado.",
+  ];
+  return boundedVisualModel(model);
+}
+export function packLocal(proposal) {
+  proposal = structuredClone(proposal);
+  const initial = buildReport(proposal);
+  for (const [index, key] of (initial.visual_model.unknown ?? []).slice(0, 32).entries())
+    proposal.observations.push({
+      id: `local-unknown-${index}`,
+      kind: "unknown",
+      subject: `Unverified ${key}`,
+      value: null,
+      reason: "Local static/document analysis does not establish this value or rendered state",
+      provenance: {
+        url: null,
+        locator: proposal.source.locator,
+        selector: key,
+        viewport: null,
+        observed_at: proposal.source.observed_at,
+        source_hash: proposal.source.source_hash,
+        method: "local-source-capability",
+      },
+    });
+  validate(proposal);
+  const report = buildReport(proposal);
+  const artifacts = {
+    "proposal.json": bytes(proposal),
+    "report.json": bytes(report),
+    "REPORT.md": Buffer.from(reportMarkdown(report)),
+    "DESIGN.md": Buffer.from(design(proposal)),
+    "handoff.json": bytes({
+      schema_version: 2,
+      method: "maker-local-source-v1",
+      source: proposal.source,
+      observations: proposal.observations,
+      proposal_only: true,
+      central_promotion: false,
+      capabilities: proposal.capabilities,
+      limitations: proposal.limitations,
+    }),
+  };
+  for (const value of Object.values(artifacts))
+    if (value.length > 4194304) throw new Error("Local artifact exceeds byte budget");
+  return {
+    proposal,
+    artifacts,
+    inventory: Object.entries(artifacts).map(([name, value]) => ({
+      name,
+      hash: hash(value),
+      bytes: value.length,
+    })),
+    summary: {
+      source: proposal.source,
+      capabilities: proposal.capabilities,
+      uncertainty: proposal.limitations.slice(0, 128),
+      swatches: report.colors.slice(0, 12).map((row) => ({
+        value: row.value,
+        kind: "inferred",
+        evidence: row.evidence,
+        method: row.provenance.method,
+      })),
+      observed_count: proposal.observations.filter((row) => row.kind === "observed").length,
+      inferred_count: proposal.token_candidates.length,
+      unknown_count: proposal.observations.filter((row) => row.kind === "unknown").length,
+      visual_model: report.visual_model,
+      report: {
+        method_version: report.method_version,
+        score: report.score,
+        score_kind: report.score_kind,
+        metrics: report.metrics,
+        sampling: {
+          total: report.sampling.total,
+          sampled: report.sampling.sampled,
+          truncated: report.sampling.truncated,
+        },
+      },
+    },
+  };
+}

package/templates/.agents/design/design-system-maker/runtime/local-request.mjs

@@ -0,0 +1,100 @@
+import { safeText } from "./contracts.mjs";
+import { identifier, relativePath } from "./io.mjs";
+import { facets } from "./local-artifacts.mjs";
+
+export function designReference(value) {
+  if (
+    !value ||
+    Object.keys(value).sort().join() !== "design_hash,id,revision" ||
+    !Number.isSafeInteger(value.revision) ||
+    value.revision < 1 ||
+    !/^[a-f\d]{64}$/.test(value.design_hash)
+  )
+    throw new Error("Exact id/revision/DESIGN hash reference required");
+  identifier(value.id);
+  return { id: value.id, revision: value.revision, design_hash: value.design_hash };
+}
+export function sourceRequest(value) {
+  const fields = {
+    repository: ["paths"],
+    "import-design": ["path", "expected_hash"],
+    "rebuild-document": ["reference"],
+    compose: ["sources", "facets"],
+  };
+  if (
+    !value ||
+    !fields[value.kind] ||
+    Object.keys(value).some(
+      (key) =>
+        ![
+          "kind",
+          "id",
+          "name",
+          "expected_revision",
+          "operation_id",
+          ...fields[value.kind],
+        ].includes(key),
+    )
+  )
+    throw new Error("Unknown local Maker command/field");
+  identifier(value.operation_id);
+  if (value.operation_id.length > 40) throw new Error("Operation ID exceeds40 characters");
+  const id = value.id ?? `ref-${value.operation_id}`;
+  identifier(id);
+  const expected_revision = value.expected_revision ?? 0;
+  if (
+    !Number.isSafeInteger(expected_revision) ||
+    expected_revision < 0 ||
+    (expected_revision > 0 && value.kind !== "rebuild-document")
+  )
+    throw new Error("Only rebuild-document can advance an existing reference");
+  const name = safeText(value.name ?? id, 128).trim();
+  if (!name) throw new Error("Maker reference name required");
+  const result = {
+    kind: value.kind,
+    operation_id: value.operation_id,
+    id,
+    name,
+    expected_revision,
+  };
+  if (value.kind === "repository") {
+    if (!Array.isArray(value.paths) || !value.paths.length || value.paths.length > 16)
+      throw new Error("Repository requires1–16 relative input paths");
+    result.paths = [
+      ...new Set(value.paths.map((path) => (path === "." ? path : relativePath(path)))),
+    ].sort();
+  } else if (value.kind === "import-design") {
+    result.path = relativePath(value.path);
+    if (!/\.md$/i.test(result.path) || !/^[a-f\d]{64}$/.test(value.expected_hash))
+      throw new Error("Bounded Markdown path and expected SHA256 required");
+    result.expected_hash = value.expected_hash;
+  } else if (value.kind === "rebuild-document") result.reference = designReference(value.reference);
+  else {
+    if (!Array.isArray(value.sources) || value.sources.length < 2 || value.sources.length > 8)
+      throw new Error("Composition requires2–8 exact source revisions");
+    result.sources = value.sources.map(designReference);
+    const ids = new Set(result.sources.map((ref) => ref.id));
+    if (ids.size !== result.sources.length || ids.has(id))
+      throw new Error("Composition source identities must be distinct from destination");
+    if (
+      !value.facets ||
+      !Object.keys(value.facets).length ||
+      Object.keys(value.facets).some((key) => !facets.includes(key))
+    )
+      throw new Error("Explicit facet priority required");
+    result.facets = {};
+    for (const key of Object.keys(value.facets).sort()) {
+      const priority = value.facets[key];
+      if (
+        !Array.isArray(priority) ||
+        !priority.length ||
+        priority.length > ids.size ||
+        new Set(priority).size !== priority.length ||
+        priority.some((ref) => !ids.has(ref))
+      )
+        throw new Error("Facet priority must contain unique selected source IDs");
+      result.facets[key] = [...priority];
+    }
+  }
+  return result;
+}

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

@@ -0,0 +1,23 @@
+import { createServer } from "node:net";
+import { hash } from "./io.mjs";
+
+export async function acquire(root) {
+  const identity = hash(Buffer.from(process.platform === "win32" ? root.toLowerCase() : root));
+  const server = createServer((socket) => socket.destroy());
+  const endpoint =
+    process.platform === "win32"
+      ? { path: `\\\\.\\pipe\\zaip-maker-${identity}`, exclusive: true }
+      : {
+          host: "127.0.0.1",
+          port: 20000 + (Number.parseInt(identity.slice(0, 8), 16) % 40000),
+          exclusive: true,
+        };
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(endpoint, resolve);
+  }).catch((error) => {
+    throw new Error(`Maker writer exclusion unavailable (${error.code}); fail closed`);
+  });
+  return () =>
+    new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+}

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

@@ -0,0 +1,107 @@
+import { designScore } from "../../../tools/visual-url/design-score.mjs";
+import { design } from "../../../tools/visual-url/proposal.mjs";
+import { boundedVisualModel, visualModel } from "../../../tools/visual-url/visual-model.mjs";
+
+export function summary(value) {
+  const prefix = `/api/extracts/${value.id}`;
+  return {
+    id: value.id,
+    design_code: value.design_code ?? null,
+    slug: value.slug,
+    name: value.name,
+    host: value.url
+      ? new URL(value.url).hostname
+      : ({
+          repository: "Repositório",
+          "design-markdown": "Documento DESIGN",
+          composition: "Composição",
+        }[value.source?.type] ?? "Fonte local"),
+    url: value.url,
+    source: value.source ?? value.proposal_summary?.source ?? null,
+    request_url: value.request_url ?? null,
+    replay_available: typeof value.request_url === "string",
+    replay_unavailable_reason: value.source
+      ? "Referência local: use rebuild-document com revisão/hash do DESIGN; reprocess-source recolhe apenas URLs."
+      : typeof value.request_url !== "string"
+        ? "URL exata original não preservada nesta revisão; forneça uma URL segura explicitamente"
+        : null,
+    trash_revision: value.trash_revision ?? 0,
+    deleted_at: value.deleted_at ?? null,
+    status: value.status,
+    failure: value.failure ?? null,
+    visual_model: boundedVisualModel(
+      value.visual_model ?? value.proposal_summary?.visual_model ?? null,
+    ),
+    revision: value.revision,
+    updated_at: value.updated_at,
+    design_score: value.design_score ?? null,
+    theme: value.visual_model?.theme?.active ?? null,
+    archetype: null,
+    grade: null,
+    score: value.proposal_summary?.report?.score ?? null,
+    score_kind: value.proposal_summary?.report?.score_kind ?? null,
+    sampling: value.proposal_summary?.report?.sampling ?? null,
+    previewVariant: "unavailable",
+    designMdPath: value.artifacts.some((item) => item.name === "DESIGN.md")
+      ? `data/entries/${value.id}/revisions/r-${String(value.revision).padStart(6, "0")}/DESIGN.md`
+      : null,
+    designMdUrl: value.artifacts.some((item) => item.name === "DESIGN.md")
+      ? `${prefix}/design?revision=${value.revision}`
+      : null,
+    previewUrl: null,
+    rawPreviewUrl: null,
+    visual: {
+      faviconUrl: value.artifacts.some((item) =>
+        ["favicon.png", "favicon.jpg", "favicon.ico"].includes(item.name),
+      )
+        ? `${prefix}/favicon?revision=${value.revision}`
+        : null,
+      faviconStatus: value.artifacts.some((item) =>
+        ["favicon.png", "favicon.jpg", "favicon.ico"].includes(item.name),
+      )
+        ? "verified"
+        : "unavailable",
+      screenshotUrl: value.artifacts.some((item) => item.name === "screenshot.png")
+        ? `${prefix}/screenshot?revision=${value.revision}`
+        : null,
+      inferred_swatches: value.proposal_summary?.swatches ?? [],
+      method: "normalized evidence, no active HTML preview",
+    },
+    provenance: value.proposal_summary?.source ?? null,
+    capabilities: value.proposal_summary?.capabilities ?? null,
+    uncertainty:
+      value.proposal_summary?.uncertainty.slice(0, 12).map((gap) => gap.slice(0, 512)) ??
+      (value.status === "failed"
+        ? [value.error]
+        : ["Extraction still collecting; rendered and token details unknown"]),
+  };
+}
+export function detail(value) {
+  const proposal = value.proposal;
+  const model =
+    proposal && value.report?.status === "measured-evidence"
+      ? visualModel(proposal, value.report)
+      : (boundedVisualModel(value.report?.visual_model) ?? null);
+  const score = designScore(proposal, value.report, model);
+  return {
+    ...value,
+    summary: summary({ ...value, visual_model: model, design_score: score }),
+    design_score: score,
+    visual_model: model,
+    designMd: proposal ? design(proposal) : value.design_markdown,
+    tokens: {
+      components: value.report?.status === "measured-evidence" ? value.report.components : [],
+      elements: proposal?.dom ?? [],
+      candidates: proposal?.token_candidates ?? [],
+      global_promotion: false,
+    },
+    quality: {
+      grade: null,
+      overall: value.report?.score ?? null,
+      status: value.report?.status ?? "legacy-unavailable",
+      score_kind: value.report?.score_kind ?? null,
+      metrics: value.report?.metrics ?? [],
+      reason: "Cobertura da extração medida; não é nota de qualidade visual, LLM ou acessibilidade",
+    },
+  };
+}

package/templates/.agents/design/design-system-maker/runtime/repository-source.mjs

@@ -0,0 +1,200 @@
+import { lstat, readdir, realpath } from "node:fs/promises";
+import { extname, isAbsolute, relative, resolve } from "node:path";
+import { declarationSampler } from "../../../tools/visual-url/css-sample.mjs";
+import { css, html } from "../../../tools/visual-url/parser.mjs";
+import { defaults, safeText } from "../../../tools/visual-url/policy.mjs";
+import { bytes, hash, read, relativePath } from "./io.mjs";
+import { jsonTokenDeclarations } from "./json-tokens.mjs";
+import { localProposal } from "./local-artifacts.mjs";
+
+const ignored =
+  /^(?:\.git|\.local|\.codex|\.claude|node_modules|dist|build|coverage|release|public-cli|\.zaip-aios|\.next|\.turbo|data|vendor|generated)$/i;
+export const sensitivePath = (path) =>
+  path
+    .split("/")
+    .some((part) =>
+      /^\.env(?:\.|$)|(?:^|[._-])(?:secrets?|credentials?|private-key)(?:[._-]|$)|^(?:id_rsa|id_ed25519)$|\.(?:pem|key|p12|pfx|crt)$/i.test(
+        part,
+      ),
+    );
+const extensions = new Set([
+  ".css",
+  ".html",
+  ".htm",
+  ".jsx",
+  ".tsx",
+  ".vue",
+  ".svelte",
+  ".js",
+  ".ts",
+  ".json",
+]);
+export async function repositoryProposal(workspace, id, paths, at = new Date().toISOString()) {
+  const root = await realpath(workspace),
+    files = [],
+    declarations = declarationSampler(defaults.declarations),
+    nodes = [],
+    gaps = [];
+  let visited = 0,
+    total = 0,
+    stopped = false;
+  const started = Date.now(),
+    seen = new Set();
+  async function walk(path, depth) {
+    if (Date.now() - started > 5000 || ++visited > 2000 || files.length >= 64 || depth > 8) {
+      stopped = true;
+      return;
+    }
+    if (path.split("/").some((part) => ignored.test(part)))
+      throw new Error("Generated/dependency input excluded");
+    if (sensitivePath(path)) {
+      gaps.push("Secret/dotenv input skipped without reading");
+      return;
+    }
+    const physical = path === "." ? root : resolve(root, relativePath(path));
+    const offset = relative(root, physical);
+    if (isAbsolute(offset) || offset.startsWith(".."))
+      throw new Error("Repository source escapes workspace");
+    // Validate every component before metadata/content access, including explicit nested inputs.
+    let current = root;
+    for (const part of offset.split(/[\\/]/).filter(Boolean)) {
+      current = resolve(current, part);
+      if ((await lstat(current)).isSymbolicLink())
+        throw new Error("Repository reparse/symlink source rejected");
+    }
+    const stat = await lstat(physical),
+      actual = await realpath(physical),
+      actualOffset = relative(root, actual);
+    if (stat.isSymbolicLink() || actualOffset.startsWith("..") || isAbsolute(actualOffset))
+      throw new Error("Repository physical path boundary rejected");
+    if (seen.has(actual)) return;
+    seen.add(actual);
+    if (stat.isDirectory()) {
+      for (const item of (await readdir(physical, { withFileTypes: true })).sort((a, b) =>
+        a.name.localeCompare(b.name),
+      )) {
+        if (ignored.test(item.name) || sensitivePath(item.name) || item.name.startsWith("."))
+          continue;
+        if (item.isSymbolicLink()) {
+          gaps.push("Repository reparse/symlink entry omitted");
+          continue;
+        }
+        if (stopped) break;
+        await walk(path === "." ? item.name : `${path}/${item.name}`, depth + 1);
+      }
+      return;
+    }
+    if (!stat.isFile() || !extensions.has(extname(path).toLowerCase())) return;
+    if (
+      /\.json$/i.test(path) &&
+      !/^(?:tokens?|design-tokens?|theme|themes|design-system|colors|typography)(?:[._-][\w-]+)?\.json$/i.test(
+        path.split("/").at(-1),
+      )
+    )
+      return;
+    if (stat.size > 262144 || total + stat.size > 2097152) {
+      stopped = true;
+      return;
+    }
+    const content = await read(root, path, 262144);
+    total += content.length;
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(content),
+      digest = hash(content);
+    files.push({ path, hash: digest, bytes: content.length });
+    const add = (result, locator = path) => {
+      for (const row of result.declarations)
+        declarations.add({ ...row, source_locator: locator, method: "repository-css" });
+      if (result.sampling?.truncated)
+        gaps.push(`CSS declarations sampled in ${safeText(path, 220)}`);
+    };
+    if (extname(path).toLowerCase() === ".json") {
+      const json = jsonTokenDeclarations(text, path, digest, at);
+      for (const row of json.declarations) declarations.add(row);
+      if (json.omitted) gaps.push(`${json.omitted} unsupported/secret/dynamic JSON fields omitted`);
+    } else if (extname(path).toLowerCase() === ".css") add(css(text, defaults, null, digest, at));
+    else if (/\.(?:html?|vue|svelte)$/i.test(path)) {
+      const parsed = html({ text, url: null }, defaults);
+      for (const row of parsed.nodes.slice(0, 500 - nodes.length))
+        nodes.push({ ...row, id: `dom-${nodes.length}`, locator: path, source_hash: digest });
+      for (const block of parsed.styles) add(css(block.text ?? block, defaults, null, digest, at));
+      for (const block of parsed.inline)
+        add(css(block.text, defaults, null, digest, at, block.selector));
+    } else {
+      // Bounded literal inventory only. No import, eval, config or Tailwind execution.
+      let count = 0;
+      for (const match of text.matchAll(
+        /(?:#[a-f\d]{3,8}\b|(?:rgb|hsl)a?\([^()\r\n]{1,128}\))/gi,
+      )) {
+        if (++count > 128) {
+          gaps.push("Source color literal inventory sampled");
+          break;
+        }
+        declarations.add({
+          property: "color",
+          value: match[0],
+          selector: `literal@L${text.slice(0, match.index).split("\n").length}`,
+          source_url: null,
+          source_locator: path,
+          source_hash: digest,
+          observed_at: at,
+          method: "repository-css",
+          redacted: false,
+        });
+      }
+      gaps.push(
+        "JS/TS/templates: literal candidates only; dynamic Tailwind/config expressions not evaluated",
+      );
+    }
+  }
+  for (const path of paths) await walk(path, 0);
+  if (!files.length) throw new Error("No supported non-secret repository files within scope");
+  const source = {
+    type: "repository",
+    url: null,
+    locator: paths
+      .map((path) => (path === "." ? "repository-root" : path))
+      .join(", ")
+      .slice(0, 512),
+    observed_at: at,
+    source_hash: hash(bytes(files)),
+    source_preserved: false,
+    files,
+    references: [],
+  };
+  const proposal = localProposal(id, source),
+    sample = declarations.finish();
+  proposal.dom = nodes;
+  for (const row of sample.declarations) {
+    const evidence = `local-${proposal.observations.length}`;
+    proposal.observations.push({
+      id: evidence,
+      kind: "observed",
+      subject: "Repository declaration; not rendered style",
+      value: safeText(`${row.property}: ${row.value}`),
+      reason: row.redacted ? "Incomplete/redacted source declaration" : null,
+      provenance: {
+        url: null,
+        locator: row.source_locator,
+        selector: row.selector,
+        observed_at: at,
+        source_hash: row.source_hash,
+        viewport: null,
+        method: row.method,
+      },
+    });
+    if (!row.redacted)
+      proposal.token_candidates.push({
+        property: row.property,
+        value: row.value,
+        kind: "inferred",
+        reason: "Repository static declaration/literal; runtime application not established",
+        evidence: [evidence],
+      });
+  }
+  proposal.limitations.push(
+    ...new Set(gaps.slice(0, 20)),
+    `${files.length} files / ${total} bytes retained as inventory; ${visited} entries visited. Source scan ${stopped ? "incomplete: budget reached" : "bounded to requested paths"}.`,
+    `${sample.sampling.truncated} declarations omitted; dynamic source expressions, assets and responsive/runtime state remain unknown.`,
+  );
+  return proposal;
+}

package/templates/.agents/design/design-system-maker/runtime/reprocess-mode.mjs

@@ -0,0 +1,17 @@
+// Preserve browser evidence across retries, including an intervening HTTP failure.
+// Explicit API mode overrides this compatibility recovery for older collections.
+export async function reprocessMode(store, previous, requested) {
+  if (requested !== undefined) return requested;
+  for (
+    let revision = previous.revision;
+    revision >= Math.max(1, previous.revision - 99);
+    revision--
+  ) {
+    const entry =
+      revision === previous.revision ? previous : await store.get(previous.id, revision);
+    if (entry?.proposal_summary?.capabilities?.runtime_rendered) return "browser";
+    const job = entry?.job_id ? await store.readJob(entry.job_id) : null;
+    if (job?.mode === "browser") return "browser";
+  }
+  return "http";
+}