spec-layer 0.7.0 → 0.8.2

package/README.md

@@ -62,7 +62,10 @@ Module 2025.10 files, rather than `ai/foundation.yaml`, needs 0.4.0 or later.
 `ai/components/`, `path` in place of `aiPath` in the manifest, and the
 `outputs` block need 0.6.0 or later. `component-specs/` beside `tokens/`,
 `componentSpecsDir`, cwd-relative manifest paths, and the `tokens/` directory
-need 0.7.0 or later.
+need 0.7.0 or later. The `census` and `config_hash` blocks inside
+`resolver.json`, and the `transform` and `resolved` fields in
+`spec-layer.meta.json`, need 0.8.0 or later; an earlier version pulls the same
+files without those fields.
 
 ## Commands
 

package/dist/cli.js

@@ -816,6 +816,15 @@ var SUPPORTED_DURATION_UNITS = ["ms", "s"];
 
 // ../extractor/src/v5/canonical.ts
 var import_js_sha2562 = __toESM(require_sha256(), 1);
+var SCHEMA_VERSION = "5.1.0";
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => compareCodeUnits(a, b)).map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`);
+    return `{${entries.join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
 
 // ../extractor/src/v5/validate.ts
 var ROOT = "<artifact>";
@@ -1317,6 +1326,7 @@ function validateLevel1(artifact) {
 }
 
 // ../extractor/src/v5/dtcg.ts
+var import_js_sha2563 = __toESM(require_sha256(), 1);
 function dtcgSegments(name) {
   const segments = [];
   const notes = [];
@@ -1435,6 +1445,15 @@ function sortTree(value) {
   const keys = Object.keys(value).sort((a, b) => rank(a) - rank(b) || compareCodeUnits(a, b));
   return Object.fromEntries(keys.map((k) => [k, sortTree(value[k])]));
 }
+function recordFact(p, tokenId, mode, transform, resolved2) {
+  let facts = p.factsById.get(tokenId);
+  if (!facts) {
+    facts = { transform: {}, resolved: {} };
+    p.factsById.set(tokenId, facts);
+  }
+  facts.transform[mode] = transform;
+  if (resolved2 !== void 0) facts.resolved[mode] = resolved2;
+}
 function reportOnce(p, entry2) {
   const key = JSON.stringify([entry2.code, entry2.path, entry2.mode ?? null, entry2.details]);
   if (p.reportKeys.has(key)) return;
@@ -1500,15 +1519,47 @@ function projectedLiteral(p, token, resolved2, onOverrideConflict) {
   const collection = p.collectionById.get(token.collection_id);
   const override = collection ? unitOverrideFor(p, token, collection) : void 0;
   let literal = resolved2;
+  let overrode = false;
   if (override !== void 0 && literal.type === "number") {
     if (token.scopes.some((s) => STATED_NUMBER_SCOPES.includes(s))) onOverrideConflict?.(override);
-    else literal = { type: "dimension", number: literal.value, unit: override };
+    else {
+      literal = { type: "dimension", number: literal.value, unit: override };
+      overrode = true;
+    }
+  }
+  const converted2 = dtcgLiteral(literal, token.scopes, p.options.values);
+  if ("omit" in converted2) return { converted: converted2, transform: null };
+  return {
+    converted: converted2,
+    transform: overrode ? "number-unit-override" : literalTransform(literal, token.scopes)
+  };
+}
+function literalTransform(value, scopes) {
+  switch (value.type) {
+    case "color":
+      return "color";
+    case "dimension":
+      return "dimension";
+    case "duration":
+      return "duration";
+    case "number":
+      return scopes.includes("FONT_WEIGHT") ? "font-weight" : "number";
+    case "cubic_bezier":
+      return "cubic-bezier";
+    case "font_family":
+      return "font-family";
+    case "string":
+    case "boolean":
+      return null;
+    default: {
+      const exhaustive = value;
+      return exhaustive;
+    }
   }
-  return dtcgLiteral(literal, token.scopes, p.options.values);
 }
 function aliasLeafType(p, token, chain, resolved2) {
   const terminal = chain.length > 0 ? p.tokenById.get(chain[chain.length - 1].token_id) : void 0;
-  return projectedLiteral(p, terminal ?? token, resolved2);
+  return projectedLiteral(p, terminal ?? token, resolved2).converted;
 }
 function modeLabels(collection) {
   const counts = /* @__PURE__ */ new Map();
@@ -1547,6 +1598,17 @@ function reportCollectionNameCollisions(p) {
 function asJson(value) {
   return JSON.parse(JSON.stringify(value));
 }
+function transformField(p, token) {
+  const facts = p.factsById.get(token.id);
+  if (!facts) return {};
+  const sorted = (source) => {
+    const keys = Object.keys(source).sort(compareCodeUnits);
+    return keys.length === 0 ? void 0 : Object.fromEntries(keys.map((k) => [k, source[k]]));
+  };
+  const transform = sorted(facts.transform);
+  const resolved2 = sorted(facts.resolved);
+  return { ...transform ? { transform } : {}, ...resolved2 ? { resolved: resolved2 } : {} };
+}
 function metaEntry(p, token, collection) {
   const labels = p.modeLabelsById.get(collection.id) ?? modeLabels(collection);
   const omitted = p.omittedIds.has(token.id);
@@ -1559,6 +1621,7 @@ function metaEntry(p, token, collection) {
     collection_id: token.collection_id,
     type: token.type,
     scopes: [...token.scopes],
+    ...omitted ? {} : transformField(p, token),
     ...token.code_syntax ? { code_syntax: token.code_syntax } : {},
     ...token.publication ? { publication: token.publication } : {},
     ...omitted ? {
@@ -1857,6 +1920,64 @@ function annotateGroups(p, tree, collection) {
     }
   }
 }
+var newAccumulator = () => ({
+  tokens: 0,
+  types: /* @__PURE__ */ new Map(),
+  present: 0,
+  missing: 0,
+  aliases: 0,
+  literals: 0,
+  scopes: /* @__PURE__ */ new Map(),
+  codeSyntaxPresent: 0,
+  codeSyntaxMissing: 0,
+  published: 0,
+  hiddenFromPublishing: 0,
+  unstated: 0,
+  omitted: 0,
+  collided: 0
+});
+var bump = (counts, key) => {
+  counts.set(key, (counts.get(key) ?? 0) + 1);
+};
+var histogram = (counts) => Object.fromEntries([...counts.keys()].sort(compareCodeUnits).map((k) => [k, counts.get(k)]));
+function censusEntry(a) {
+  return {
+    tokens: a.tokens,
+    types: histogram(a.types),
+    descriptions: { present: a.present, missing: a.missing },
+    aliases: a.aliases,
+    literals: a.literals,
+    scopes: histogram(a.scopes),
+    code_syntax: { present: a.codeSyntaxPresent, missing: a.codeSyntaxMissing },
+    publication: {
+      published: a.published,
+      hidden_from_publishing: a.hiddenFromPublishing,
+      unstated: a.unstated
+    },
+    ...a.omitted > 0 ? { omitted: a.omitted } : {},
+    ...a.collided > 0 ? { collided: a.collided } : {}
+  };
+}
+function styleCensus(tree) {
+  const a = newAccumulator();
+  const walk = (node) => {
+    if (typeof node !== "object" || node === null || Array.isArray(node)) return;
+    const record = node;
+    if ("$value" in record) {
+      a.tokens += 1;
+      bump(a.types, typeof record.$type === "string" ? record.$type : "unknown");
+      if (typeof record.$description === "string" && record.$description.length > 0) a.present += 1;
+      else a.missing += 1;
+      return;
+    }
+    for (const [key, value] of Object.entries(record)) {
+      if (key.startsWith("$")) continue;
+      walk(value);
+    }
+  };
+  walk(tree);
+  return { tokens: a.tokens, types: histogram(a.types), descriptions: { present: a.present, missing: a.missing } };
+}
 function foundationDtcg(artifact, options = {}) {
   const p = {
     artifact,
@@ -1871,7 +1992,8 @@ function foundationDtcg(artifact, options = {}) {
     omittedIds: /* @__PURE__ */ new Set(),
     collidedIds: /* @__PURE__ */ new Set(),
     report: [],
-    reportKeys: /* @__PURE__ */ new Set()
+    reportKeys: /* @__PURE__ */ new Set(),
+    factsById: /* @__PURE__ */ new Map()
   };
   indexPaths(p);
   omitInexpressibleTypes(p);
@@ -1879,23 +2001,46 @@ function foundationDtcg(artifact, options = {}) {
   reportCollectionNameCollisions(p);
   const files = {};
   const plans = [];
+  const census = {};
   const taken = new Set(RESERVED_FILE_NAMES);
   for (const collection of artifact.collections) {
     for (const mode of collection.modes) {
       const tree = {};
+      const a = newAccumulator();
       for (const token of artifact.tokens) {
-        if (token.collection_id !== collection.id || p.omittedIds.has(token.id)) continue;
+        if (token.collection_id !== collection.id) continue;
+        if (p.omittedIds.has(token.id)) {
+          a.omitted += 1;
+          if (p.collidedIds.has(token.id)) a.collided += 1;
+          continue;
+        }
         const leaf = tokenLeaf(p, token, collection, mode.id);
-        if (leaf) setLeaf(tree, p.segmentsById.get(token.id) ?? [], leaf);
+        if (!leaf) continue;
+        setLeaf(tree, p.segmentsById.get(token.id) ?? [], leaf);
+        a.tokens += 1;
+        bump(a.types, typeof leaf.$type === "string" ? leaf.$type : "unknown");
+        const modeLabel = modeLabelOf(p, collection, mode.id);
+        if (p.factsById.get(token.id)?.transform[modeLabel] === "alias") a.aliases += 1;
+        else a.literals += 1;
+        if (token.description.length > 0) a.present += 1;
+        else a.missing += 1;
+        for (const scope of token.scopes) bump(a.scopes, scope);
+        if (token.code_syntax) a.codeSyntaxPresent += 1;
+        else a.codeSyntaxMissing += 1;
+        if (token.publication?.published) a.published += 1;
+        if (token.publication?.hidden_from_publishing) a.hiddenFromPublishing += 1;
+        if (!token.publication) a.unstated += 1;
       }
       annotateGroups(p, tree, collection);
       const file = fileNameFor(collection, mode, taken);
       plans.push({ collection, modeId: mode.id, file });
       files[file] = sortTree(tree);
+      census[file] = censusEntry(a);
     }
   }
   const styles = styleFiles(p);
   Object.assign(files, styles);
+  for (const [file, tree] of Object.entries(styles)) census[file] = styleCensus(tree);
   const resolver = buildResolver(p, plans, Object.keys(styles).sort(compareCodeUnits));
   p.report.sort((a, b) => compareCodeUnits(a.path, b.path) || compareCodeUnits(a.code, b.code) || compareCodeUnits(a.mode ?? "", b.mode ?? ""));
   const meta = {};
@@ -1906,7 +2051,25 @@ function foundationDtcg(artifact, options = {}) {
     meta[p.collidedIds.has(token.id) ? `${path} [${token.id}]` : path] = metaEntry(p, token, collection);
   }
   const sortedMeta = Object.fromEntries(Object.entries(meta).sort(([a], [b]) => compareCodeUnits(a, b)));
-  return { files, resolver, meta: sortedMeta, report: p.report };
+  const codeSyntax = {};
+  for (const [path, entry2] of Object.entries(sortedMeta)) {
+    if (entry2.code_syntax) codeSyntax[path] = entry2.code_syntax;
+  }
+  const sourceFileName = artifact.spec_layer.source.file_name;
+  const extension = {
+    schema_version: SCHEMA_VERSION,
+    content_hash: artifact.spec_layer.export.content_hash,
+    config_hash: `sha256:${(0, import_js_sha2563.sha256)(canonicalJson(p.options))}`,
+    source: {
+      provider: "figma",
+      ...typeof sourceFileName === "string" && sourceFileName.length > 0 ? { file_name: sourceFileName } : {}
+    },
+    completeness: artifact.completeness,
+    code_syntax: codeSyntax,
+    census: Object.fromEntries(Object.keys(census).sort(compareCodeUnits).map((k) => [k, census[k]])),
+    report: p.report
+  };
+  return { files, resolver, meta: sortedMeta, report: p.report, extension };
 }
 function omitInexpressibleTypes(p) {
   for (const token of p.artifact.tokens) {
@@ -2007,9 +2170,10 @@ function tokenLeaf(p, token, collection, modeId) {
       });
       return null;
     }
+    recordFact(p, token.id, mode, "alias", typed.$value);
     return { $type: typed.$type, $value: `{${targetPath}}`, ...description };
   }
-  const converted2 = projectedLiteral(p, token, value.value, (override) => {
+  const projected = projectedLiteral(p, token, value.value, (override) => {
     reportOnce(p, {
       code: "unit_override_conflicts_with_scope",
       severity: "warning",
@@ -2018,6 +2182,7 @@ function tokenLeaf(p, token, collection, modeId) {
       details: { id: token.id, override, scopes: [...token.scopes] }
     });
   });
+  const converted2 = projected.converted;
   if ("omit" in converted2) {
     reportOnce(p, {
       code: converted2.omit,
@@ -2029,6 +2194,7 @@ function tokenLeaf(p, token, collection, modeId) {
     });
     return null;
   }
+  if (projected.transform !== null) recordFact(p, token.id, mode, projected.transform);
   return { $type: converted2.$type, $value: converted2.$value, ...description };
 }
 function dtcgExportFiles(out) {
@@ -2036,7 +2202,10 @@ function dtcgExportFiles(out) {
 `;
   const files = {};
   for (const name of Object.keys(out.files).sort(compareCodeUnits)) files[name] = text(out.files[name]);
-  files["resolver.json"] = text(out.resolver);
+  files["resolver.json"] = text({
+    ...out.resolver,
+    $extensions: { "com.spec-layer": out.extension }
+  });
   files["spec-layer.meta.json"] = text(out.meta);
   files["report.json"] = text(out.report);
   return files;
@@ -2546,7 +2715,7 @@ ${imports.join("\n")}
 }
 
 // ../extractor/src/v5/componentContext.ts
-var import_js_sha2563 = __toESM(require_sha256(), 1);
+var import_js_sha2564 = __toESM(require_sha256(), 1);
 
 // ../extractor/src/libraryBundle.ts
 var LIBRARY_BUNDLE_SCHEMA = "spec-layer-library-bundle";
@@ -2614,7 +2783,7 @@ function parseLibraryBundle(input) {
 }
 
 // ../extractor/src/libraryBundleHash.ts
-var import_js_sha2564 = __toESM(require_sha256(), 1);
+var import_js_sha2565 = __toESM(require_sha256(), 1);
 
 // src/bundle.ts
 function parseBundle(raw) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spec-layer",
-  "version": "0.7.0",
+  "version": "0.8.2",
   "description": "Pull design-system context published by the Spec Layer Figma plugin",
   "license": "MIT",
   "type": "module",