@zaip-ai/cli 6.3.0 → 7.5.0

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

@@ -0,0 +1,118 @@
+import { bytes, hash } from "./io.mjs";
+import {
+  emptyModel,
+  facets,
+  finalizeModel,
+  localProposal,
+  localToken,
+} from "./local-artifacts.mjs";
+
+export function composeProposal(id, inputs, priorities, at = new Date().toISOString()) {
+  const references = inputs.map((input) => input.reference),
+    selected = new Map(inputs.map((input) => [input.reference.id, input]));
+  const source = {
+    type: "composition",
+    url: null,
+    locator: `composition/${id}`,
+    observed_at: at,
+    source_hash: hash(bytes({ references, priorities })),
+    source_preserved: false,
+    files: [],
+    references,
+  };
+  const proposal = localProposal(id, source),
+    model = emptyModel(),
+    conflicts = [];
+  const copy = (token, input, selector) =>
+    token &&
+    localToken(
+      proposal,
+      token.property,
+      token.value,
+      `collection/${input.reference.id}/r-${input.reference.revision}/DESIGN.md`,
+      selector,
+      input.reference.design_hash,
+      "design-composition",
+      {
+        source_reference: input.reference,
+        source_evidence: (token.evidence ?? []).slice(0, 16),
+        source_method: token.provenance?.method ?? "unknown",
+      },
+    );
+  for (const facet of facets) {
+    const order = (priorities[facet] ?? []).map((id) => selected.get(id));
+    if (!order.length) continue;
+    if (facet === "components") {
+      const chosen = order.find((input) => input.model?.components?.length);
+      if (chosen)
+        model.components = chosen.model.components.slice(0, 12).map((component) => ({
+          tag: component.tag,
+          role: component.role ?? "component",
+          selector: component.selector,
+          text: "",
+          tokens: Object.fromEntries(
+            Object.entries(component.tokens ?? {}).map(([key, token]) => [
+              key,
+              copy(token, chosen, component.selector),
+            ]),
+          ),
+        }));
+      if (order.filter((input) => input.model?.components?.length).length > 1)
+        conflicts.push({
+          facet,
+          key: "components",
+          selected: chosen.reference,
+          reason: "First nonempty component facet wins; alternative structures not merged",
+        });
+      continue;
+    }
+    if (Array.isArray(model.tokens[facet])) {
+      const chosen = order.find((input) => input.model?.tokens?.[facet]?.length);
+      if (chosen)
+        model.tokens[facet] = chosen.model.tokens[facet]
+          .slice(0, 12)
+          .map((token, index) => copy(token, chosen, `${facet}.step-${index + 1}`));
+      const alternatives = order
+        .filter((input) => input.model?.tokens?.[facet]?.length)
+        .map((input) => ({
+          reference: input.reference,
+          values: input.model.tokens[facet].map((token) => token.value),
+        }));
+      if (new Set(alternatives.map((input) => JSON.stringify(input.values))).size > 1)
+        conflicts.push({ facet, key: "scale", selected: chosen.reference, alternatives });
+      continue;
+    }
+    for (const key of Object.keys(model.tokens[facet])) {
+      const candidates = order.filter((input) => input.model?.tokens?.[facet]?.[key]);
+      if (!candidates.length) continue;
+      model.tokens[facet][key] = copy(
+        candidates[0].model.tokens[facet][key],
+        candidates[0],
+        `${facet}.${key}`,
+      );
+      if (new Set(candidates.map((input) => input.model.tokens[facet][key].value)).size > 1)
+        conflicts.push({
+          facet,
+          key,
+          selected: candidates[0].reference,
+          alternatives: candidates.map((input) => ({
+            reference: input.reference,
+            value: input.model.tokens[facet][key].value,
+          })),
+        });
+    }
+  }
+  proposal.composition = {
+    method: "explicit-facet-priority-v1",
+    priorities,
+    conflicts: conflicts.slice(0, 128),
+    conflicts_omitted: Math.max(0, conflicts.length - 128),
+  };
+  proposal.local_visual_model = finalizeModel(model, "explicit-facet-composition-v1");
+  proposal.limitations.push(
+    "Facetas não selecionadas permanecem desconhecidas; prioridade usa o primeiro valor disponível por papel e a primeira escala/estrutura não vazia.",
+    `${conflicts.length} conflitos declarados; fontes fixadas por identidade/revisão/hash, sem alterar os originais.`,
+    "Composição não comprova que cores, tipografia e componentes combinados tenham sido renderizados juntos.",
+  );
+  return proposal;
+}

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

@@ -0,0 +1,154 @@
+import { normalizeColor } from "../../../tools/visual-url/colors.mjs";
+import {
+  colorRoles,
+  emptyModel,
+  finalizeModel,
+  localProposal,
+  localToken,
+  typographyProperties,
+} from "./local-artifacts.mjs";
+
+function propertyFor(role, value) {
+  const [group, key] = role.split(".");
+  if (group === "colors" && colorRoles.includes(key)) return "color";
+  if (group === "typography") return typographyProperties[key] ?? null;
+  if (/^step-\d{1,2}$/.test(key ?? ""))
+    return (
+      {
+        spacing: "padding",
+        radii: "border-radius",
+        shadows: "box-shadow",
+        borders: normalizeColor(value)
+          ? "border-color"
+          : /^(solid|dashed|dotted|none)$/.test(value)
+            ? "border-style"
+            : "border-width",
+      }[group] ?? null
+    );
+  return null;
+}
+export function markdownProposal(id, content, source) {
+  if (!Buffer.isBuffer(content) || content.length > 262144 || content.includes(0))
+    throw new Error("Markdown must be bounded UTF-8 text");
+  const text = new TextDecoder("utf-8", { fatal: true }).decode(content);
+  const lines = text.split(/\r?\n/);
+  if (lines.length > 4096) throw new Error("Markdown line budget exceeded");
+  const proposal = localProposal(id, source),
+    model = emptyModel(),
+    primitives = new Map(),
+    bindings = [],
+    components = [];
+  let frontmatter = false,
+    group = null,
+    unsupported = 0;
+  for (const [index, line] of lines.entries()) {
+    if (index === 0 && line.trim() === "---") {
+      frontmatter = true;
+      continue;
+    }
+    if (frontmatter && line.trim() === "---") {
+      frontmatter = false;
+      continue;
+    }
+    if (frontmatter) {
+      const section = /^(colors|typography|spacing|radii|borders|shadows):\s*$/.exec(line);
+      if (section) {
+        group = section[1];
+        continue;
+      }
+      const pair = /^(\s{0,4})([a-z][\w.-]{0,63}):\s*["']?([^"'\r\n]{1,256})["']?\s*$/.exec(line);
+      if (pair)
+        bindings.push({
+          role: pair[1] && group ? `${group}.${pair[2]}` : pair[2],
+          value: pair[3].trim(),
+          line: index + 1,
+        });
+      else if (line.trim()) unsupported++;
+      continue;
+    }
+    if (line.startsWith("|")) {
+      const cells = line
+        .split("|")
+        .slice(1, -1)
+        .map((cell) => cell.trim());
+      const [name, value] = cells;
+      if (/^(colors|typography|spacing|radii|borders|shadows)\.[\w.-]+$/.test(name ?? "")) {
+        if (propertyFor(name, value)) bindings.push({ role: name, value, line: index + 1 });
+        else primitives.set(name, { value, line: index + 1 });
+      } else if (line.trim() && !/\|\s*(?:Token|Role|Property|Pair|Value|---)/i.test(line))
+        unsupported++;
+    } else {
+      const component = /^- (component-\d+) \((.{1,512})\): (.{1,2048})\.$/.exec(line);
+      if (component && components.length < 12)
+        components.push({ selector: component[2], mapping: component[3], line: index + 1 });
+      else if (line.trim() && !line.startsWith("#")) unsupported++;
+    }
+  }
+  if (frontmatter) throw new Error("Unterminated Markdown frontmatter");
+  const token = (property, value, line, selector) =>
+    localToken(
+      proposal,
+      property,
+      value,
+      source.locator,
+      selector,
+      source.source_hash,
+      "markdown-declaration",
+      { line },
+    );
+  let interpreted = 0;
+  for (const binding of bindings.slice(0, 256)) {
+    const primitive = primitives.get(binding.value);
+    const value = primitive?.value ?? binding.value;
+    const property = propertyFor(binding.role, value);
+    const row = property && token(property, value, primitive?.line ?? binding.line, binding.role);
+    if (!row) {
+      unsupported++;
+      continue;
+    }
+    const [category, name] = binding.role.split(".");
+    if (Array.isArray(model.tokens[category])) {
+      if (model.tokens[category].length < 12) model.tokens[category].push(row);
+    } else model.tokens[category][name] = row;
+    interpreted++;
+  }
+  const properties = {
+    foreground: "color",
+    background: "background-color",
+    border: "border-color",
+    radius: "border-radius",
+    padding: "padding",
+    font_family: "font-family",
+    font_size: "font-size",
+    font_weight: "font-weight",
+    shadow: "box-shadow",
+  };
+  for (const component of components) {
+    const tokens = {};
+    for (const mapping of component.mapping.split(";")) {
+      const match = /^\s*([\w_]+) → ([\w.-]+)\s*$/.exec(mapping);
+      const primitive = match && primitives.get(match[2]),
+        property = match && properties[match[1]];
+      if (primitive && property)
+        tokens[match[1]] = token(property, primitive.value, primitive.line, component.selector);
+    }
+    if (Object.values(tokens).some(Boolean))
+      model.components.push({
+        tag: "div",
+        role: "document-component",
+        selector: component.selector,
+        text: "",
+        tokens,
+      });
+  }
+  proposal.local_visual_model = finalizeModel(model, "design-markdown-v1");
+  proposal.limitations.push(
+    `${interpreted} vínculos semânticos interpretados; ${unsupported} linhas/valores fora do formato suportado. Prosa não se torna token observado.`,
+    "Suporta frontmatter simples e tabelas de primitivas/papéis e mapeamentos do DESIGN gerado pelo Maker; YAML complexo e conteúdo livre não executados.",
+  );
+  if (!interpreted && !model.components.length)
+    proposal.limitations.push(
+      "Nenhum token suportado encontrado; referência preserva hash e lacuna, sem fabricar estilos.",
+    );
+  return proposal;
+}

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

@@ -0,0 +1,137 @@
+import { handoff } from "../../../tools/visual-url/handoff.mjs";
+import { iconFormat } from "../../../tools/visual-url/icon.mjs";
+import { evidenceLimits } from "../../../tools/visual-url/policy.mjs";
+import { design, validate } from "../../../tools/visual-url/proposal.mjs";
+import { buildReport, reportMarkdown } from "../../../tools/visual-url/report.mjs";
+import { artifactNames } from "./contracts.mjs";
+import { bytes, hash, read } from "./io.mjs";
+
+export async function importExtraction(workspace, result) {
+  if (
+    result?.product_writes !== false ||
+    result.output !== `.agents/private/state/visual-url/${result.receipt?.extraction_id}` ||
+    result.receipt.schema_version !== 1 ||
+    !Array.isArray(result.receipt.files) ||
+    result.receipt.files.length < 3 ||
+    result.receipt.files.length > artifactNames.length
+  )
+    throw new Error("Extraction receipt namespace/inventory invalid");
+  const persistedReceipt = await read(workspace, `${result.output}/receipt.json`, 65536);
+  if (!persistedReceipt.equals(bytes(result.receipt)))
+    throw new Error("Persisted extraction receipt differs from runtime result");
+  const artifacts = {};
+  const names = new Set();
+  for (const item of result.receipt.files) {
+    if (!item || !artifactNames.includes(item.path) || names.has(item.path))
+      throw new Error("Unknown/duplicate extraction artifact");
+    names.add(item.path);
+    const value = await read(
+      workspace,
+      `${result.output}/${item.path}`,
+      item.path === "screenshot.png"
+        ? evidenceLimits.screenshot_bytes
+        : evidenceLimits.text_artifact_bytes,
+    );
+    if (value.length !== item.bytes || hash(value) !== item.hash)
+      throw new Error("Extraction receipt/source bytes corrupted");
+    artifacts[item.path] = value;
+  }
+  if (!["proposal.json", "handoff.json", "DESIGN.md"].every((name) => names.has(name)))
+    throw new Error("Required extraction artifacts missing");
+  const proposal = validate(JSON.parse(artifacts["proposal.json"].toString("utf8")));
+  if (
+    proposal.extraction_id !== result.receipt.extraction_id ||
+    !artifacts["DESIGN.md"].equals(Buffer.from(design(proposal))) ||
+    !artifacts["handoff.json"].equals(bytes(handoff(proposal)))
+  )
+    throw new Error("Extraction normalized proposal/handoff mismatch");
+  if (
+    proposal.screenshot &&
+    (!artifacts["screenshot.png"] ||
+      artifacts["screenshot.png"].length !== proposal.screenshot.bytes ||
+      hash(artifacts["screenshot.png"]) !== proposal.screenshot.hash)
+  )
+    throw new Error("Extraction screenshot receipt mismatch");
+  let report = null;
+  if (proposal.favicon) {
+    const icon = proposal.favicon;
+    const data = artifacts[icon.path];
+    if (
+      !data ||
+      data.length !== icon.bytes ||
+      hash(data) !== icon.hash ||
+      iconFormat(data).name !== icon.path ||
+      iconFormat(data).mime !== icon.mime
+    )
+      throw new Error("Favicon receipt/magic mismatch");
+  }
+  if (
+    Object.keys(artifacts).some(
+      (name) => name.startsWith("favicon.") && name !== proposal.favicon?.path,
+    )
+  )
+    throw new Error("Unexpected favicon artifact without provenance");
+  if (artifacts["report.json"] || artifacts["REPORT.md"]) {
+    if (!artifacts["report.json"] || !artifacts["REPORT.md"])
+      throw new Error("Measured report export pair missing");
+    report = buildReport(proposal);
+    // Older exports have the identical evidence formula but no visual projection.
+    const originalReport = JSON.parse(artifacts["report.json"].toString("utf8"));
+    const verifiedReport = { ...report };
+    if (!Object.hasOwn(originalReport, "visual_model")) delete verifiedReport.visual_model;
+    if (
+      !artifacts["report.json"]?.equals(bytes(verifiedReport)) ||
+      !artifacts["REPORT.md"]?.equals(Buffer.from(reportMarkdown(report)))
+    )
+      throw new Error("Measured report differs from retained evidence/formula");
+  }
+  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,
+      swatches: report
+        ? report.colors.slice(0, 12).map((item) => ({
+            value: item.value,
+            kind: "inferred",
+            evidence: item.evidence,
+            method: "static-css-declaration",
+          }))
+        : proposal.token_candidates
+            .filter((item) => /^#[a-f0-9]{3,8}$/i.test(item.value))
+            .slice(0, 12)
+            .map((item) => ({
+              value: item.value,
+              kind: "inferred",
+              evidence: item.evidence,
+              method: "static-css-declaration",
+            })),
+      observed_count: proposal.observations.filter((item) => item.kind === "observed").length,
+      inferred_count: proposal.token_candidates.length,
+      unknown_count: proposal.observations.filter((item) => item.kind === "unknown").length,
+      visual_model: report?.visual_model ?? null,
+      ...(report
+        ? {
+            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/io.mjs

@@ -0,0 +1,121 @@
+import { createHash, randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { lstat, mkdir, open, readdir, realpath, rename, unlink } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+
+export const bytes = (value) => Buffer.from(`${JSON.stringify(value, null, 2)}\n`);
+export const hash = (value) => createHash("sha256").update(value).digest("hex");
+export function identifier(value) {
+  if (
+    typeof value !== "string" ||
+    !/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(value) ||
+    /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])$/i.test(value)
+  )
+    throw new Error("Invalid collection identifier");
+  return value;
+}
+export function relativePath(value) {
+  if (
+    typeof value !== "string" ||
+    !value ||
+    value.length > 220 ||
+    isAbsolute(value) ||
+    /[\\:<>"|?*]/.test(value) ||
+    [...value].some((char) => char.charCodeAt(0) < 32) ||
+    value
+      .split("/")
+      .some(
+        (part) =>
+          !part ||
+          part === "." ||
+          part === ".." ||
+          /[. ]$/.test(part) ||
+          /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(part),
+      )
+  )
+    throw new Error("Unsafe collection artifact path");
+  return value;
+}
+export async function path(root, value, create = false) {
+  let current = root;
+  const parts = relativePath(value).split("/");
+  for (const [index, part] of parts.entries()) {
+    current = resolve(current, part);
+    let stat = await lstat(current).catch((error) => {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    });
+    if (!stat && create && index < parts.length - 1) {
+      await mkdir(current).catch((error) => {
+        if (error.code !== "EEXIST") throw error;
+      });
+      stat = await lstat(current);
+    }
+    if (
+      stat?.isSymbolicLink() ||
+      (stat && index < parts.length - 1 && !stat.isDirectory()) ||
+      (stat && index === parts.length - 1 && !stat.isFile())
+    )
+      throw new Error("Collection path has symlink/reparse or wrong type");
+  }
+  return current;
+}
+export async function directory(root, value) {
+  return dirname(await path(root, `${value}/_marker`, true));
+}
+export async function read(root, value, maximum = 8388608) {
+  const file = await path(root, value);
+  const handle = await open(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  try {
+    const stat = await handle.stat();
+    const actual = await realpath(file);
+    const offset = relative(root, actual);
+    if (!stat.isFile() || stat.size > maximum || offset.startsWith("..") || isAbsolute(offset))
+      throw new Error("Collection read boundary/size violation");
+    const value = await handle.readFile();
+    if (value.length > maximum) throw new Error("Collection file exceeds byte limit");
+    return value;
+  } finally {
+    await handle.close();
+  }
+}
+export async function optional(root, value) {
+  try {
+    return await read(root, value);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+export async function json(root, value) {
+  const value_ = await optional(root, value);
+  return value_ === null ? null : JSON.parse(value_.toString("utf8"));
+}
+export async function write(root, value, content, immutable = false) {
+  const file = await path(root, value, true);
+  const previous = await optional(root, value);
+  if (immutable && previous !== null) {
+    if (!previous.equals(content)) throw new Error("Immutable collection artifact differs");
+    return;
+  }
+  const temporary = resolve(dirname(file), `_stage-${randomUUID()}`);
+  const handle = await open(temporary, "wx", 0o600);
+  try {
+    await handle.writeFile(content);
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  await path(root, value);
+  await rename(temporary, file);
+}
+export async function names(root, value) {
+  const folder = await directory(root, value);
+  const items = await readdir(folder, { withFileTypes: true });
+  if (items.some((item) => item.isSymbolicLink()))
+    throw new Error("Collection directory contains reparse entry");
+  return items;
+}
+export async function remove(root, value) {
+  await unlink(await path(root, value));
+}

package/templates/.agents/design/design-system-maker/runtime/job-progress.mjs

@@ -0,0 +1,50 @@
+export function queuedJob(value) {
+  return {
+    ...value,
+    phase: "queued",
+    started_at: null,
+    completed_at: null,
+    duration_ms: null,
+    progress: { percent: null, resources_received: 0 },
+    events: [{ at: value.created_at, phase: "queued", resources_received: 0 }],
+  };
+}
+export function advanceJob(value, update) {
+  const at = update.at ?? new Date().toISOString();
+  const terminal = ["completed", "failed"].includes(update.phase);
+  const started = value.started_at ?? (!terminal && update.phase !== "queued" ? at : null);
+  const received = update.resources_received ?? value.progress?.resources_received ?? 0;
+  return {
+    ...value,
+    ...(update.browser
+      ? { browser: update.browser }
+      : terminal && value.browser
+        ? { browser: { ...value.browser, state: "closed", action: null } }
+        : {}),
+    phase: update.phase,
+    status: update.status ?? value.status,
+    updated_at: at,
+    started_at: started,
+    completed_at: terminal ? at : null,
+    duration_ms: started === null ? null : Math.max(0, Date.parse(at) - Date.parse(started)),
+    progress: { percent: null, resources_received: received },
+    events: [
+      ...(value.events ?? []),
+      { at, phase: update.phase, resources_received: received },
+    ].slice(-64),
+  };
+}
+export const phaseLabels = {
+  queued: "Na fila",
+  "fetch-html": "Coletando HTML",
+  "parse-css": "Analisando CSS",
+  "fetch-css": "Coletando folhas CSS",
+  "build-report": "Gerando relatório",
+  "verify-artifacts": "Verificando artefatos",
+  commit: "Persistindo revisão",
+  completed: "Relatório gerado",
+  failed: "Extração falhou",
+  "browser-open": "Abrindo navegador próprio",
+  "browser-wait": "Aguardando página e ação humana na janela própria",
+  "browser-capture": "Capturando DOM, estilos e imagem reais",
+};

package/templates/.agents/design/design-system-maker/runtime/json-tokens.mjs

@@ -0,0 +1,88 @@
+import { normalizeColor } from "../../../tools/visual-url/colors.mjs";
+import { safeVisualValue } from "../../../tools/visual-url/visual-model.mjs";
+
+// A small data reader, not a configuration/module loader. Dynamic aliases remain unknown.
+export function jsonTokenDeclarations(text, path, sourceHash, observedAt) {
+  let input;
+  try {
+    input = JSON.parse(text);
+  } catch {
+    throw new Error("Malformed token JSON; source text not echoed");
+  }
+  const declarations = [];
+  let visited = 0,
+    omitted = 0;
+  const visit = (value, parts, depth, inheritedType = null) => {
+    if (++visited > 1024 || depth > 8) {
+      omitted++;
+      return;
+    }
+    if (
+      value &&
+      typeof value === "object" &&
+      !Array.isArray(value) &&
+      (Object.hasOwn(value, "$value") || Object.hasOwn(value, "value"))
+    ) {
+      const candidate = value.$value ?? value.value;
+      const type = value.$type ?? value.type ?? inheritedType;
+      if (
+        candidate &&
+        typeof candidate === "object" &&
+        typeof candidate.value === "number" &&
+        ["px", "rem", "em"].includes(candidate.unit)
+      )
+        visit(`${candidate.value}${candidate.unit}`, parts, depth + 1, type);
+      else visit(candidate, parts, depth + 1, type);
+      return;
+    }
+    if (value && typeof value === "object") {
+      for (const [key, child] of Object.entries(value).slice(0, 128)) {
+        if (
+          !/^[\w-]{1,64}$/.test(key) ||
+          /password|secret|credential|api[-_]?key|access[-_]?token|authorization|cookie/i.test(key)
+        ) {
+          omitted++;
+          continue;
+        }
+        visit(child, [...parts, key], depth + 1, inheritedType);
+      }
+      return;
+    }
+    if (!parts.length || !["string", "number"].includes(typeof value)) return;
+    const scalar = String(value),
+      name = parts.join("-"),
+      color = normalizeColor(scalar);
+    let property = color
+      ? `--${name}`
+      : /fontfamily|font-family|family/i.test(name) || inheritedType === "fontFamily"
+        ? "font-family"
+        : /fontweight|font-weight|weight/i.test(name)
+          ? "font-weight"
+          : /radius/i.test(name)
+            ? "border-radius"
+            : /spacing|space|padding|gap/i.test(name)
+              ? "padding"
+              : /fontsize|font-size/i.test(name)
+                ? "font-size"
+                : null;
+    const normalized = property && safeVisualValue(property, scalar);
+    if (!normalized) {
+      omitted++;
+      return;
+    }
+    const theme = parts.find((part) => /^(dark|light)$/.test(part));
+    declarations.push({
+      property,
+      value: normalized,
+      selector: theme ? `[data-theme="${theme}"]` : ":root",
+      source_url: null,
+      source_locator: `${path}#/${parts.join("/")}`,
+      source_hash: sourceHash,
+      observed_at: observedAt,
+      method: "repository-json",
+      redacted: false,
+    });
+  };
+  visit(input, [], 0);
+  return { declarations, omitted };
+}