spec-layer 0.5.0 → 0.7.0

package/dist/cli.js

@@ -559,7 +559,8 @@ var require_sha256 = __commonJS({
 import { parseArgs } from "node:util";
 
 // src/commands.ts
-import { join as join7 } from "node:path";
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join8, resolve as resolve5 } from "node:path";
 
 // ../extractor/src/statesMatrix.ts
 var STATE_ORDER = [
@@ -1333,7 +1334,15 @@ function dtcgSegments(name) {
   }
   return { segments, notes };
 }
-var slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "unnamed";
+function trimDashes(s) {
+  let start = 0;
+  let end = s.length;
+  while (start < end && s[start] === "-") start += 1;
+  while (end > start && s[end - 1] === "-") end -= 1;
+  return s.slice(start, end);
+}
+var dtcgSlug = (s) => trimDashes(s.toLowerCase().replace(/[^a-z0-9]+/g, "-")) || "unnamed";
+var slug = dtcgSlug;
 var RESERVED_FILE_NAMES = [
   "styles.typography.json",
   "styles.effects.json",
@@ -1611,15 +1620,15 @@ function styleMember(p, property, scopes, path, name) {
     });
     return null;
   }
-  const converted = dtcgLiteral(property.resolved, scopes, p.options.values);
-  if ("omit" in converted) {
-    if (converted.omit === "unit_not_expressible") {
+  const converted2 = dtcgLiteral(property.resolved, scopes, p.options.values);
+  if ("omit" in converted2) {
+    if (converted2.omit === "unit_not_expressible") {
       reportOnce(p, {
         code: "unit_not_expressible",
         severity: "info",
         path,
         message: `The ${name} unit is not a DTCG dimension unit; the value is kept under $extensions.`,
-        details: { property: name, ...converted.details }
+        details: { property: name, ...converted2.details }
       });
       const d = property.resolved;
       return { extension: { value: d.number, unit: d.unit } };
@@ -1629,11 +1638,11 @@ function styleMember(p, property, scopes, path, name) {
       severity: "warning",
       path,
       message: `The ${name} property has a type DTCG cannot state and was omitted.`,
-      details: { property: name, ...converted.details }
+      details: { property: name, ...converted2.details }
     });
     return null;
   }
-  return { value: converted.$value };
+  return { value: converted2.$value };
 }
 var TYPOGRAPHY_MEMBERS = [
   ["font_family", "fontFamily", []],
@@ -1733,8 +1742,8 @@ function effectLeaf(p, style, path) {
       }
       const raw = effect[field];
       if (raw === void 0) continue;
-      const converted = dtcgLiteral(raw, [], p.options.values);
-      if (!("omit" in converted)) shadow[name] = converted.$value;
+      const converted2 = dtcgLiteral(raw, [], p.options.values);
+      if (!("omit" in converted2)) shadow[name] = converted2.$value;
     }
     shadow.inset = effect.type === "inner_shadow";
     shadows.push(shadow);
@@ -2000,7 +2009,7 @@ function tokenLeaf(p, token, collection, modeId) {
     }
     return { $type: typed.$type, $value: `{${targetPath}}`, ...description };
   }
-  const converted = projectedLiteral(p, token, value.value, (override) => {
+  const converted2 = projectedLiteral(p, token, value.value, (override) => {
     reportOnce(p, {
       code: "unit_override_conflicts_with_scope",
       severity: "warning",
@@ -2009,18 +2018,18 @@ function tokenLeaf(p, token, collection, modeId) {
       details: { id: token.id, override, scopes: [...token.scopes] }
     });
   });
-  if ("omit" in converted) {
+  if ("omit" in converted2) {
     reportOnce(p, {
-      code: converted.omit,
+      code: converted2.omit,
       severity: "warning",
       path,
       mode,
-      message: converted.omit === "type_not_expressible" ? `DTCG has no ${String(converted.details.type)} type; the value was omitted.` : `DTCG dimensions take px or rem; a ${String(converted.details.unit)} value was omitted.`,
-      details: { id: token.id, ...converted.details }
+      message: converted2.omit === "type_not_expressible" ? `DTCG has no ${String(converted2.details.type)} type; the value was omitted.` : `DTCG dimensions take px or rem; a ${String(converted2.details.unit)} value was omitted.`,
+      details: { id: token.id, ...converted2.details }
     });
     return null;
   }
-  return { $type: converted.$type, $value: converted.$value, ...description };
+  return { $type: converted2.$type, $value: converted2.$value, ...description };
 }
 function dtcgExportFiles(out) {
   const text = (v) => `${JSON.stringify(v, null, 2)}
@@ -2033,6 +2042,509 @@ function dtcgExportFiles(out) {
   return files;
 }
 
+// ../extractor/src/v5/outputs/naming.ts
+var NAME_CASES = ["kebab", "camel", "pascal", "snake", "constant"];
+function splitWords(segment) {
+  return segment.replace(new RegExp("(\\p{Ll})(\\p{Lu})", "gu"), "$1 $2").split(/[^\p{L}\p{N}]+/u).filter((w) => w.length > 0);
+}
+function pathWords(path) {
+  return path.split(".").flatMap((seg) => {
+    const words = splitWords(seg);
+    return words.length > 0 ? words : ["_"];
+  });
+}
+function joinWords(words, nameCase) {
+  const lower = words.map((w) => w.toLowerCase());
+  const cap = (w) => w.charAt(0).toUpperCase() + w.slice(1);
+  switch (nameCase) {
+    case "kebab":
+      return lower.join("-");
+    case "snake":
+      return lower.join("_");
+    case "constant":
+      return lower.join("_").toUpperCase();
+    case "camel":
+      return lower.map((w, i) => i === 0 ? w : cap(w)).join("");
+    case "pascal":
+      return lower.map(cap).join("");
+    default: {
+      const exhaustive = nameCase;
+      return exhaustive;
+    }
+  }
+}
+function deriveName(path, nameCase) {
+  return joinWords(pathWords(path), nameCase);
+}
+function sortReport(entries) {
+  return [...entries].sort((a, b) => compareCodeUnits(a.path, b.path) || compareCodeUnits(a.code, b.code) || compareCodeUnits(a.mode ?? "", b.mode ?? ""));
+}
+function resolveNames(paths, meta, rules) {
+  const report2 = [];
+  const candidates = /* @__PURE__ */ new Map();
+  for (const path of [...paths].sort(compareCodeUnits)) {
+    let name = null;
+    let source = "derived";
+    const declared = rules.codeSyntaxKey ? meta[path]?.code_syntax?.[rules.codeSyntaxKey] : void 0;
+    if (declared !== void 0) {
+      name = rules.acceptDeclared(declared);
+      if (name !== null) {
+        source = "code_syntax";
+      } else {
+        report2.push({
+          code: "code_syntax_not_usable",
+          severity: "info",
+          path,
+          message: `The declared ${rules.codeSyntaxKey} identifier "${declared}" is not a name this format can use; the name was derived instead.`,
+          details: { declared, platform: rules.codeSyntaxKey ?? "" }
+        });
+      }
+    }
+    if (name === null) name = rules.affix(deriveName(path, rules.nameCase));
+    const list = candidates.get(name) ?? [];
+    list.push({ path, source });
+    candidates.set(name, list);
+  }
+  const names = /* @__PURE__ */ new Map();
+  const map = {};
+  for (const [name, list] of candidates) {
+    if (list.length > 1) {
+      const collided = list.map((c) => c.path).sort(compareCodeUnits);
+      for (const c of list) {
+        report2.push({
+          code: "name_collision",
+          severity: "error",
+          path: c.path,
+          message: `${list.length} tokens would share the name ${name}; all were omitted.`,
+          details: { name, paths: collided }
+        });
+      }
+      continue;
+    }
+    names.set(list[0].path, name);
+    map[list[0].path] = { name, source: list[0].source };
+  }
+  const sortedMap = Object.fromEntries(Object.entries(map).sort(([a], [b]) => compareCodeUnits(a, b)));
+  return { names, map: sortedMap, report: sortReport(report2) };
+}
+
+// ../extractor/src/v5/outputs/css.ts
+var CSS_INDEX_FILE = "index.css";
+var CSS_DEFAULTS = {
+  case: "kebab",
+  root: ":root",
+  modeSelector: '[data-theme="{mode}"]'
+};
+var CSS_HEADER_PREFIX = "/* Generated by spec-layer";
+var EXT = "com.spec-layer";
+var CUSTOM_PROPERTY = /^--[A-Za-z0-9_-]+$/;
+var BARE_IDENT = /^[A-Za-z_][A-Za-z0-9_-]*$/;
+function acceptCssDeclared(declared) {
+  if (CUSTOM_PROPERTY.test(declared)) return declared;
+  if (BARE_IDENT.test(declared)) return `--${declared}`;
+  return null;
+}
+var asRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : null;
+function collectLeaves(tree, prefix, out) {
+  const node = asRecord(tree);
+  if (!node) return;
+  if ("$value" in node) {
+    const ours = asRecord(asRecord(node.$extensions)?.[EXT]);
+    out.push({
+      path: prefix.join("."),
+      type: typeof node.$type === "string" ? node.$type : "",
+      value: node.$value,
+      ext: ours
+    });
+    return;
+  }
+  for (const key of Object.keys(node)) {
+    if (key.startsWith("$")) continue;
+    collectLeaves(node[key], [...prefix, key], out);
+  }
+}
+var unpointer = (s) => s.replace(/~1/g, "/").replace(/~0/g, "~");
+var refFile = (src) => {
+  const r = asRecord(src);
+  return r && typeof r.$ref === "string" ? r.$ref : null;
+};
+function sourcesOf(resolver) {
+  const out = [];
+  for (const { $ref } of resolver.resolutionOrder) {
+    const set = /^#\/sets\/(.+)$/.exec($ref);
+    const mod = /^#\/modifiers\/(.+)$/.exec($ref);
+    if (set) {
+      const label = unpointer(set[1]);
+      for (const src of resolver.sets[label]?.sources ?? []) {
+        const file = refFile(src);
+        if (file) out.push({ collection: label, mode: null, file, isDefault: true });
+      }
+    } else if (mod) {
+      const label = unpointer(mod[1]);
+      const m = resolver.modifiers[label];
+      if (!m) continue;
+      for (const [context, srcs] of Object.entries(m.contexts)) {
+        for (const src of srcs) {
+          const file = refFile(src);
+          if (file) out.push({ collection: label, mode: context, file, isDefault: context === m.default });
+        }
+      }
+    }
+  }
+  return out;
+}
+var modeSlug = (file) => file.replace(/\.json$/, "").split(".").slice(1).join(".");
+var collectionSlug = (file) => file.split(".")[0];
+function cssFileNames(sources) {
+  const taken = /* @__PURE__ */ new Set([CSS_INDEX_FILE]);
+  const out = /* @__PURE__ */ new Map();
+  for (const s of sources) {
+    if (out.has(s.file)) continue;
+    const base = s.mode === null ? dtcgSlug(s.collection) : `${dtcgSlug(s.collection)}.${modeSlug(s.file)}`;
+    let candidate = `${base}.css`;
+    let n = 1;
+    while (taken.has(candidate)) {
+      n += 1;
+      candidate = `${base}-${n}.css`;
+    }
+    taken.add(candidate);
+    out.set(s.file, candidate);
+  }
+  return out;
+}
+var REF = /^\{(.+)\}$/;
+function hexChannels(hex) {
+  const at = (i) => parseInt(hex.slice(i, i + 2), 16);
+  return [at(1), at(3), at(5)];
+}
+var quoteFamily = (f) => `"${f.replace(/["\\]/g, "\\$&")}"`;
+function report(ctx, entry2) {
+  ctx.report.push({ ...entry2, path: ctx.path, ...ctx.mode !== void 0 ? { mode: ctx.mode } : {} });
+}
+function cssValue(ctx, type, value, property) {
+  const member = property !== void 0 ? { property } : {};
+  if (typeof value === "string") {
+    const ref = REF.exec(value);
+    if (ref) {
+      const name = ctx.alive.has(ref[1]) ? ctx.names.get(ref[1]) : void 0;
+      if (name !== void 0) return `var(${name})`;
+      report(ctx, {
+        code: "reference_target_omitted",
+        severity: "warning",
+        message: `References ${ref[1]}, which this output does not emit; the value was omitted.`,
+        details: { target: ref[1], ...member }
+      });
+      return null;
+    }
+  }
+  switch (type) {
+    case "color": {
+      if (typeof value === "string") return value;
+      const c = asRecord(value);
+      if (c && typeof c.hex === "string" && typeof c.alpha === "number") {
+        if (c.alpha === 1) return c.hex;
+        const [r, g, b] = hexChannels(c.hex);
+        return `rgb(${r} ${g} ${b} / ${c.alpha})`;
+      }
+      break;
+    }
+    case "dimension":
+    case "duration": {
+      if (typeof value === "string") return value;
+      const d = asRecord(value);
+      if (d && typeof d.value === "number" && typeof d.unit === "string") return `${d.value}${d.unit}`;
+      break;
+    }
+    case "number":
+    case "fontWeight":
+      if (typeof value === "number") return String(value);
+      break;
+    case "cubicBezier":
+      if (Array.isArray(value) && value.length === 4 && value.every((n) => typeof n === "number")) {
+        return `cubic-bezier(${value.join(", ")})`;
+      }
+      break;
+    case "fontFamily":
+      if (typeof value === "string") return quoteFamily(value);
+      if (Array.isArray(value) && value.every((f) => typeof f === "string")) {
+        return value.map(quoteFamily).join(", ");
+      }
+      break;
+    default:
+      break;
+  }
+  report(ctx, {
+    code: "not_expressible",
+    severity: "warning",
+    message: `CSS has no form for this ${type || "untyped"} value; it was omitted.`,
+    details: { type, value, ...member }
+  });
+  return null;
+}
+var TEXT_TRANSFORM = { original: "none", upper: "uppercase", lower: "lowercase", title: "capitalize" };
+var TEXT_DECORATION = { none: "none", underline: "underline", strikethrough: "line-through" };
+var TYPOGRAPHY_MEMBERS2 = [
+  ["fontFamily", "fontFamily"],
+  ["fontSize", "dimension"],
+  ["fontWeight", "fontWeight"],
+  ["lineHeight", "number"],
+  ["letterSpacing", "dimension"]
+];
+var TEXT_MEMBERS = [
+  ["textTransform", "textCase", TEXT_TRANSFORM],
+  ["textDecoration", "textDecoration", TEXT_DECORATION]
+];
+function typographyMemberKeys(value, ext) {
+  const keys = [];
+  for (const [key] of TYPOGRAPHY_MEMBERS2) {
+    if (key in value) keys.push(key);
+  }
+  for (const key of ["lineHeight", "letterSpacing"]) {
+    if (key in value) continue;
+    const d = asRecord(ext[key]);
+    if (d && typeof d.value === "number" && typeof d.unit === "string") keys.push(key);
+  }
+  for (const [key, extKey] of TEXT_MEMBERS) {
+    if (typeof ext[extKey] === "string") keys.push(key);
+  }
+  return keys;
+}
+function converted(ctx, property, from, to) {
+  report(ctx, {
+    code: "value_converted",
+    severity: "info",
+    message: `${property} was restated from ${String(from.value)}${String(from.unit)} as ${to}.`,
+    details: { property, from, to }
+  });
+}
+function extensionDimension(ctx, ext, key, name, percentTo) {
+  const d = asRecord(ext[key]);
+  if (!d || typeof d.value !== "number" || typeof d.unit !== "string") return null;
+  if (d.unit === "%") {
+    const to = percentTo(canonicalNumber(d.value / 100));
+    converted(ctx, key, d, to);
+    return `${name}: ${to};`;
+  }
+  return `${name}: ${d.value}${d.unit};`;
+}
+function typographyDecls(ctx, leaf, names) {
+  const decls = [];
+  const declaredPaths = [];
+  const value = asRecord(leaf.value) ?? {};
+  const ext = leaf.ext ?? {};
+  const nameFor = (key) => names.get(`${leaf.path}.${key}`);
+  for (const [key, type] of TYPOGRAPHY_MEMBERS2) {
+    if (!(key in value)) continue;
+    const name = nameFor(key);
+    if (name === void 0) continue;
+    const css = cssValue(ctx, type, value[key], key);
+    if (css !== null) {
+      decls.push(`${name}: ${css};`);
+      declaredPaths.push(`${leaf.path}.${key}`);
+    }
+  }
+  if (!("lineHeight" in value)) {
+    const name = nameFor("lineHeight");
+    if (name !== void 0) {
+      const d = extensionDimension(ctx, ext, "lineHeight", name, (n) => String(n));
+      if (d) {
+        decls.push(d);
+        declaredPaths.push(`${leaf.path}.lineHeight`);
+      }
+    }
+  }
+  if (!("letterSpacing" in value)) {
+    const name = nameFor("letterSpacing");
+    if (name !== void 0) {
+      const d = extensionDimension(ctx, ext, "letterSpacing", name, (n) => `${n}em`);
+      if (d) {
+        decls.push(d);
+        declaredPaths.push(`${leaf.path}.letterSpacing`);
+      }
+    }
+  }
+  for (const [key, extKey, table] of TEXT_MEMBERS) {
+    const raw = ext[extKey];
+    if (typeof raw !== "string") continue;
+    const name = nameFor(key);
+    if (name === void 0) continue;
+    const css = table[raw];
+    if (css !== void 0) {
+      decls.push(`${name}: ${css};`);
+      declaredPaths.push(`${leaf.path}.${key}`);
+    } else {
+      report(ctx, {
+        code: "not_expressible",
+        severity: "info",
+        message: `CSS text properties have no form for ${extKey} "${raw}"; it was omitted.`,
+        details: { property: extKey, value: raw }
+      });
+    }
+  }
+  return { decls, declaredPaths };
+}
+var SHADOW_MEMBERS = [
+  ["offsetX", "dimension"],
+  ["offsetY", "dimension"],
+  ["blur", "dimension"],
+  ["spread", "dimension"],
+  ["color", "color"]
+];
+function shadowDecl(ctx, leaf, name) {
+  const layers = Array.isArray(leaf.value) ? leaf.value : [];
+  const omit = (reason, message) => {
+    report(ctx, { code: "not_expressible", severity: "warning", message, details: { reason } });
+    return null;
+  };
+  if (layers.length === 0) return omit("no_visible_shadow", "The style has no visible shadow, so no box-shadow was written.");
+  const parts = [];
+  for (const layer of layers) {
+    const l = asRecord(layer);
+    if (!l) return omit("layer_not_an_object", "A shadow layer is not an object; the style was omitted.");
+    const members = [];
+    for (const [key, type] of SHADOW_MEMBERS) {
+      if (!(key in l)) return omit(`missing_${key}`, `A shadow layer has no ${key}, which box-shadow needs; the style was omitted.`);
+      const css = cssValue(ctx, type, l[key], key);
+      if (css === null) return null;
+      members.push(css);
+    }
+    parts.push(`${l.inset === true ? "inset " : ""}${members.join(" ")}`);
+  }
+  return `${name}: ${parts.join(", ")};`;
+}
+var commentSafe = (text) => text.replace(/\*\//g, "* /").replace(/[\r\n]+/g, " ");
+function headerText(header, nameCase) {
+  return `${CSS_HEADER_PREFIX} from library ${commentSafe(header.libraryId)}, foundation ${header.contentHash}, ${header.platform}/${header.format}/${nameCase}.
+   Do not edit. Change the design in Figma, republish, and run spec-layer pull. */`;
+}
+function emitPass(sources, leavesByFile, names, alive, root, template, modes) {
+  const entries = [];
+  const declared = /* @__PURE__ */ new Set();
+  const firstFile = /* @__PURE__ */ new Map();
+  const blocks = /* @__PURE__ */ new Map();
+  for (const s of sources) {
+    const perCollection = modes?.[s.collection];
+    const selector = s.isDefault ? root : (perCollection ?? template).replace(/\{mode\}/g, modeSlug(s.file)).replace(/\{collection\}/g, collectionSlug(s.file));
+    const decls = [];
+    const declaredHere = [];
+    for (const leaf of leavesByFile.get(s.file) ?? []) {
+      const ctx = { names, alive, report: entries, path: leaf.path, ...s.mode !== null ? { mode: s.mode } : {} };
+      if (leaf.type === "typography") {
+        const t = typographyDecls(ctx, leaf, names);
+        decls.push(...t.decls);
+        for (const p of t.declaredPaths) {
+          declared.add(p);
+          declaredHere.push(p);
+        }
+      } else {
+        const name = names.get(leaf.path);
+        if (name === void 0) continue;
+        if (leaf.type === "shadow") {
+          const d = shadowDecl(ctx, leaf, name);
+          if (d !== null) {
+            decls.push(d);
+            declared.add(leaf.path);
+            declaredHere.push(leaf.path);
+          }
+        } else {
+          const v = cssValue(ctx, leaf.type, leaf.value);
+          if (v !== null) {
+            decls.push(`${name}: ${v};`);
+            declared.add(leaf.path);
+            declaredHere.push(leaf.path);
+          }
+        }
+      }
+    }
+    if (decls.length === 0) continue;
+    for (const p of declaredHere) if (!firstFile.has(p)) firstFile.set(p, s.file);
+    const comment = `/* ${commentSafe(`${s.collection}${s.mode !== null ? `, ${s.mode}` : ""}`)} */`;
+    const existing = blocks.get(s.file);
+    if (existing) existing.decls.push(...decls);
+    else blocks.set(s.file, { selector, comment, decls });
+  }
+  return { blocks, entries, declared, firstFile };
+}
+function cssOutput(exp, header, options = {}) {
+  const nameCase = options.case ?? CSS_DEFAULTS.case;
+  const root = options.root ?? CSS_DEFAULTS.root;
+  const template = options.modeSelector ?? CSS_DEFAULTS.modeSelector;
+  const sources = sourcesOf(exp.resolver);
+  const leavesByFile = /* @__PURE__ */ new Map();
+  for (const s of sources) {
+    if (!leavesByFile.has(s.file)) {
+      const out = [];
+      collectLeaves(exp.files[s.file] ?? {}, [], out);
+      leavesByFile.set(s.file, out);
+    }
+  }
+  const candidatePaths = /* @__PURE__ */ new Set();
+  for (const leaves of leavesByFile.values()) {
+    for (const leaf of leaves) {
+      if (leaf.type === "typography") {
+        const value = asRecord(leaf.value) ?? {};
+        const ext = leaf.ext ?? {};
+        for (const key of typographyMemberKeys(value, ext)) candidatePaths.add(`${leaf.path}.${key}`);
+      } else {
+        candidatePaths.add(leaf.path);
+      }
+    }
+  }
+  const resolved2 = resolveNames([...candidatePaths], exp.meta, {
+    codeSyntaxKey: "WEB",
+    acceptDeclared: acceptCssDeclared,
+    affix: (body) => `--${body}`,
+    nameCase
+  });
+  const names = resolved2.names;
+  const emit = (alive2) => emitPass(sources, leavesByFile, names, alive2, root, template, options.modes);
+  let alive = new Set(names.keys());
+  let pass = emit(alive);
+  for (; ; ) {
+    if (pass.declared.size === alive.size) break;
+    alive = pass.declared;
+    pass = emit(alive);
+  }
+  const fileNames = cssFileNames(sources);
+  const map = {};
+  for (const [path, entry2] of Object.entries(resolved2.map)) {
+    const from = pass.firstFile.get(path);
+    if (alive.has(path) && from !== void 0) map[path] = { ...entry2, file: fileNames.get(from) };
+  }
+  const entries = [...resolved2.report, ...pass.entries];
+  const shared = [...new Set(sources.filter((s) => !s.isDefault && options.modes?.[s.collection] === void 0).map((s) => s.collection))].sort(compareCodeUnits);
+  if (shared.length > 1) {
+    for (const collection of shared) {
+      entries.push({
+        code: "mode_selector_shared",
+        severity: "warning",
+        path: collection,
+        message: `${shared.length} collections with modes share the selector template ${template}; one attribute cannot carry both axes. Declare a selector per collection under outputs[].modes.`,
+        details: { modifiers: shared, selector: template }
+      });
+    }
+  }
+  const head = headerText(header, nameCase);
+  const files = {};
+  const imports = [];
+  for (const [source, block] of pass.blocks) {
+    const name = fileNames.get(source);
+    files[name] = `${head}
+
+${block.selector} {
+  ${block.comment}
+${block.decls.map((d) => `  ${d}`).join("\n")}
+}
+`;
+    imports.push(block.comment, `@import "./${name}";`);
+  }
+  if (imports.length > 0) files[CSS_INDEX_FILE] = `${head}
+
+${imports.join("\n")}
+`;
+  return { files, map, report: sortReport(entries) };
+}
+
 // ../extractor/src/v5/componentContext.ts
 var import_js_sha2563 = __toESM(require_sha256(), 1);
 
@@ -2101,6 +2613,9 @@ function parseLibraryBundle(input) {
   };
 }
 
+// ../extractor/src/libraryBundleHash.ts
+var import_js_sha2564 = __toESM(require_sha256(), 1);
+
 // src/bundle.ts
 function parseBundle(raw) {
   try {
@@ -2119,57 +2634,377 @@ function parseBundle(raw) {
     }
   }
 }
-
-// src/config.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "node:fs";
-import { join as join2 } from "node:path";
-
-// src/credentials.ts
-import { readFileSync, writeFileSync, existsSync, chmodSync } from "node:fs";
-import { join } from "node:path";
-var CREDENTIALS_NAME = "speclayer.local.json";
-var unreadable = () => new Error(
-  `${CREDENTIALS_NAME} cannot be read. Delete it, then run the setup command from the plugin's Library screen.`
-);
-function readCredentials(cwd) {
-  const path = join(cwd, CREDENTIALS_NAME);
-  if (!existsSync(path)) return null;
-  let parsed;
+
+// src/config.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync4 } from "node:fs";
+import { join as join4 } from "node:path";
+
+// src/credentials.ts
+import { readFileSync, writeFileSync, existsSync, chmodSync } from "node:fs";
+import { join } from "node:path";
+var CREDENTIALS_NAME = "speclayer.local.json";
+var unreadable = () => new Error(
+  `${CREDENTIALS_NAME} cannot be read. Delete it, then run the setup command from the plugin's Library screen.`
+);
+function readCredentials(cwd) {
+  const path = join(cwd, CREDENTIALS_NAME);
+  if (!existsSync(path)) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    throw unreadable();
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw unreadable();
+  const record = parsed;
+  if (typeof record.libraryId !== "string" || typeof record.key !== "string") throw unreadable();
+  return { libraryId: record.libraryId, key: record.key };
+}
+function writeCredentials(cwd, stored) {
+  const path = join(cwd, CREDENTIALS_NAME);
+  const replaced = existsSync(path);
+  const body = { libraryId: stored.libraryId, key: stored.key };
+  writeFileSync(path, `${JSON.stringify(body, null, 2)}
+`, { mode: 384 });
+  chmodSync(path, 384);
+  return { replaced };
+}
+
+// src/detect.ts
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+var CODE_SYNTAX_KEY = {
+  web: "WEB",
+  ios: "iOS",
+  android: "ANDROID",
+  flutter: null
+};
+var PLATFORMS = ["web", "ios", "android", "flutter"];
+var AGENT_HOSTS = ["claude", "cursor", "copilot", "windsurf", "gemini", "agents-md"];
+var uniq = (xs) => [...new Set(xs)];
+function readPackageJson(cwd) {
+  const path = join2(cwd, "package.json");
+  if (!existsSync2(path)) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const record = parsed;
+  const deps = {};
+  for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
+    const block = record[field];
+    if (typeof block !== "object" || block === null) continue;
+    for (const [name, range] of Object.entries(block)) {
+      if (typeof range === "string") deps[name] = range;
+    }
+  }
+  return { deps };
+}
+function majorOf(range) {
+  const m = /^[\^~>=<\s]*v?(\d+)/.exec(range.trim());
+  return m ? Number(m[1]) : null;
+}
+var DEP_SIGNALS = [
+  { dep: "react", platform: "web", framework: "react" },
+  { dep: "next", platform: "web", framework: "next" },
+  { dep: "vue", platform: "web", framework: "vue" },
+  { dep: "nuxt", platform: "web", framework: "nuxt" },
+  { dep: "svelte", platform: "web", framework: "svelte" },
+  { dep: "@sveltejs/kit", platform: "web", framework: "sveltekit" },
+  { dep: "@angular/core", platform: "web", framework: "angular" },
+  { dep: "solid-js", platform: "web", framework: "solid" },
+  { dep: "lit", platform: "web", framework: "lit" },
+  { dep: "astro", platform: "web", framework: "astro" },
+  { dep: "react-native", platform: "ios", framework: "react-native" },
+  { dep: "expo", platform: "ios", framework: "expo" },
+  { dep: "tailwindcss", platform: "web", tokenTool: "tailwind" },
+  { dep: "styled-components", platform: "web", framework: "styled-components" },
+  { dep: "@emotion/react", platform: "web", framework: "emotion" },
+  { dep: "sass", platform: "web", framework: "sass" },
+  { dep: "@vanilla-extract/css", platform: "web", framework: "vanilla-extract" },
+  { dep: "@stitches/react", platform: "web", framework: "stitches" },
+  { dep: "@pandacss/dev", platform: "web", framework: "panda" },
+  { dep: "style-dictionary", tokenTool: "style-dictionary" },
+  { dep: "@tokens-studio/sd-transforms", tokenTool: "tokens-studio" },
+  { dep: "typescript", language: "typescript" }
+];
+var FILE_SIGNALS = [
+  { test: (n) => n === "Package.swift", signal: "Swift package", platform: "ios", language: "swift" },
+  { test: (n) => n.endsWith(".xcodeproj") || n.endsWith(".xcworkspace"), signal: "Xcode project", platform: "ios", language: "swift" },
+  { test: (n) => n === "Podfile", signal: "CocoaPods", platform: "ios" },
+  { test: (n) => /^build\.gradle(\.kts)?$/.test(n) || /^settings\.gradle(\.kts)?$/.test(n), signal: "Gradle build", platform: "android", language: "kotlin" },
+  { test: (n) => n === "AndroidManifest.xml", signal: "Android manifest", platform: "android" },
+  { test: (n) => n === "pubspec.yaml", signal: "Flutter or Dart package", platform: "flutter", language: "dart" },
+  { test: (n) => n === "tsconfig.json", signal: "TypeScript config", language: "typescript" },
+  { test: (n) => n === "package.json", signal: "npm package", language: "javascript" },
+  { test: (n) => n === "deno.json" || n === "deno.jsonc", signal: "Deno config", language: "typescript" },
+  { test: (n) => n === "Cargo.toml", signal: "Cargo manifest", language: "rust" },
+  { test: (n) => n === "go.mod", signal: "Go module", language: "go" },
+  { test: (n) => n === "pyproject.toml" || n === "requirements.txt", signal: "Python project", language: "python" },
+  { test: (n) => n === "Gemfile", signal: "Ruby bundle", language: "ruby" },
+  { test: (n) => n === "composer.json", signal: "Composer package", language: "php" },
+  { test: (n) => n.endsWith(".csproj") || n.endsWith(".sln"), signal: ".NET project", language: "csharp" },
+  { test: (n) => n === "pom.xml", signal: "Maven build", language: "java" },
+  { test: (n) => /^tailwind\.config\.(js|cjs|mjs|ts)$/.test(n), signal: "Tailwind config", platform: "web", tokenTool: "tailwind" },
+  { test: (n) => /^(style-dictionary\.config|sd\.config)\.(js|cjs|mjs|ts|json)$/.test(n), signal: "Style Dictionary config", tokenTool: "style-dictionary" },
+  { test: (n) => n === "index.html" || n === "vite.config.ts" || n === "vite.config.js", signal: "web entry", platform: "web" },
+  { test: (n) => n === "CLAUDE.md" || n === ".claude", signal: "Claude Code", agent: "claude" },
+  { test: (n) => n === ".cursor" || n === ".cursorrules", signal: "Cursor", agent: "cursor" },
+  { test: (n) => n === ".windsurf" || n === ".windsurfrules", signal: "Windsurf", agent: "windsurf" },
+  { test: (n) => n === "GEMINI.md", signal: "Gemini CLI", agent: "gemini" },
+  { test: (n) => n === "AGENTS.md", signal: "AGENTS.md", agent: "agents-md" }
+];
+function detectRepo(cwd) {
+  const platforms = [];
+  const languages = [];
+  const frameworks = [];
+  const tokenTools = [];
+  const agents = [];
+  const evidence = [];
+  let styleDictionaryMajor = null;
+  let names = [];
+  try {
+    names = readdirSync(cwd).sort();
+  } catch {
+    names = [];
+  }
+  for (const name of names) {
+    for (const rule of FILE_SIGNALS) {
+      if (!rule.test(name)) continue;
+      evidence.push({ signal: rule.signal, file: name });
+      if (rule.platform) platforms.push(rule.platform);
+      if (rule.language) languages.push(rule.language);
+      if (rule.framework) frameworks.push(rule.framework);
+      if (rule.tokenTool) tokenTools.push(rule.tokenTool);
+      if (rule.agent) agents.push(rule.agent);
+    }
+  }
+  if (existsSync2(join2(cwd, ".github", "copilot-instructions.md")) || existsSync2(join2(cwd, ".github", "instructions"))) {
+    evidence.push({ signal: "GitHub Copilot", file: ".github/copilot-instructions.md" });
+    agents.push("copilot");
+  }
+  const pkg = readPackageJson(cwd);
+  if (pkg) {
+    for (const rule of DEP_SIGNALS) {
+      const range = pkg.deps[rule.dep];
+      if (range === void 0) continue;
+      evidence.push({ signal: `${rule.dep} dependency`, file: "package.json" });
+      if (rule.platform) platforms.push(rule.platform);
+      if (rule.framework) frameworks.push(rule.framework);
+      if (rule.tokenTool) tokenTools.push(rule.tokenTool);
+      if (rule.language) languages.push(rule.language);
+      if (rule.dep === "style-dictionary") styleDictionaryMajor = majorOf(range);
+    }
+    if (pkg.deps["react-native"] !== void 0 || pkg.deps.expo !== void 0) platforms.push("android");
+  }
+  const order = (p) => PLATFORMS.indexOf(p);
+  const hostOrder = (a) => AGENT_HOSTS.indexOf(a);
+  return {
+    platforms: uniq(platforms).sort((a, b) => order(a) - order(b)),
+    languages: uniq(languages).sort(),
+    frameworks: uniq(frameworks).sort(),
+    tokenTools: uniq(tokenTools).sort(),
+    agents: uniq(agents).sort((a, b) => hostOrder(a) - hostOrder(b)),
+    styleDictionaryMajor,
+    evidence
+  };
+}
+function isPlatform(value) {
+  return PLATFORMS.includes(value);
+}
+function isAgentHost(value) {
+  return AGENT_HOSTS.includes(value);
+}
+
+// src/outputs.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+
+// src/visibleDir.ts
+import {
+  closeSync,
+  existsSync as existsSync3,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readSync,
+  readdirSync as readdirSync2,
+  renameSync,
+  rmSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { isAbsolute, join as join3, relative, resolve } from "node:path";
+var inside = (parent, child) => {
+  const rel = relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+};
+var isDotfile = (name) => name.startsWith(".");
+function carriesMarker(abs, marker) {
+  const newlines = (marker.match(/\n/g) ?? []).length;
+  const wantBytes = Buffer.byteLength(marker, "utf8") + newlines;
+  const fd = openSync(abs, "r");
+  try {
+    const buf = Buffer.alloc(wantBytes);
+    const read = readSync(fd, buf, 0, wantBytes, 0);
+    const text = buf.subarray(0, read).toString("utf8").replace(/\r\n/g, "\n");
+    return text.startsWith(marker);
+  } finally {
+    closeSync(fd);
+  }
+}
+function visibleDirProblem(cwd, outDir, dir, marker, others, configKey) {
+  const root = resolve(cwd);
+  const abs = resolve(cwd, dir);
+  if (!inside(root, abs) || abs === root) return `${dir} is outside this directory. Choose a path inside the repository.`;
+  if (inside(resolve(cwd, outDir), abs)) return `${dir} is inside ${outDir}, which pull replaces wholesale. Choose a path outside it.`;
+  for (const other of others) {
+    const otherAbs = resolve(cwd, other);
+    if (inside(abs, otherAbs) || inside(otherAbs, abs)) return `${dir} and ${other} overlap. Give each output its own directory.`;
+  }
+  if (!existsSync3(abs)) return null;
+  if (!lstatSync(abs).isDirectory()) return `${dir} exists and is not a directory. Choose another path or remove the file.`;
+  const foreign = `${dir} holds files spec-layer did not write. Set ${configKey} in speclayer.json to another path, or move them.`;
+  for (const entry2 of readdirSync2(abs, { withFileTypes: true })) {
+    if (isDotfile(entry2.name)) continue;
+    if (!entry2.isFile()) return foreign;
+    try {
+      if (!carriesMarker(join3(abs, entry2.name), marker)) return foreign;
+    } catch {
+      return `${dir}/${entry2.name} could not be read.`;
+    }
+  }
+  return null;
+}
+function writeAtomically(abs, text) {
+  const partial = `${abs}.partial`;
+  writeFileSync2(partial, text);
+  try {
+    renameSync(partial, abs);
+  } catch (err) {
+    rmSync(partial, { force: true });
+    throw err;
+  }
+}
+function writeVisibleDir(cwd, dir, marker, files, last) {
+  const abs = resolve(cwd, dir);
+  const names = Object.keys(files).filter((n) => n !== last);
+  if (last !== void 0 && last in files) names.push(last);
+  if (names.length === 0 && !existsSync3(abs)) return [];
+  mkdirSync(abs, { recursive: true });
+  for (const name of names) writeAtomically(join3(abs, name), files[name]);
+  const keep = new Set(names);
+  for (const entry2 of readdirSync2(abs, { withFileTypes: true })) {
+    if (isDotfile(entry2.name) || keep.has(entry2.name) || !entry2.isFile()) continue;
+    const path = join3(abs, entry2.name);
+    if (carriesMarker(path, marker)) rmSync(path);
+  }
+  return names;
+}
+
+// src/outputs.ts
+var FORMATS = [
+  { platform: "web", format: "css", defaultPath: "tokens", defaultCase: "kebab", headerPrefix: CSS_HEADER_PREFIX }
+];
+var knownFormats = () => FORMATS.map((f) => `${f.platform}/${f.format}`).join(", ");
+var specOf = (platform, format) => FORMATS.find((f) => f.platform === platform && f.format === format) ?? null;
+function defaultOutputs(platforms) {
+  return FORMATS.filter((f) => f.defaultPath !== null && platforms.includes(f.platform)).map((f) => ({ platform: f.platform, format: f.format, path: f.defaultPath, case: f.defaultCase }));
+}
+function withDefaults(existing, platforms) {
+  const covered = new Set(existing.map((o) => o.platform));
+  return [...existing, ...defaultOutputs(platforms.filter((p) => !covered.has(p)))];
+}
+var outputId = (o) => `${o.platform}-${o.format}`;
+function parseOutput(value, index) {
+  const at = `speclayer.json outputs[${index}]`;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${at} must be an object.`);
+  const r = value;
+  if (typeof r.platform !== "string" || typeof r.format !== "string") {
+    throw new Error(`${at} needs "platform" and "format". Known: ${knownFormats()}.`);
+  }
+  const spec = specOf(r.platform, r.format);
+  if (!spec) throw new Error(`${at}: unknown platform/format "${r.platform}/${r.format}". Known: ${knownFormats()}.`);
+  const str = (key) => {
+    if (r[key] !== void 0 && typeof r[key] !== "string") throw new Error(`${at} "${key}" must be a string.`);
+    return r[key];
+  };
+  const path = str("path") ?? spec.defaultPath;
+  if (path === null) throw new Error(`${at} needs "path": ${spec.platform} has no default location.`);
+  const nameCase = str("case");
+  if (nameCase !== void 0 && !NAME_CASES.includes(nameCase)) {
+    throw new Error(`${at} "case" takes ${NAME_CASES.join(", ")}.`);
+  }
+  const root = str("root");
+  const modeSelector = str("modeSelector");
+  let modes;
+  if (r.modes !== void 0) {
+    const m = r.modes;
+    if (typeof m !== "object" || m === null || Array.isArray(m) || !Object.values(m).every((v) => typeof v === "string")) {
+      throw new Error(`${at} "modes" must map collection names to selector strings.`);
+    }
+    modes = m;
+  }
+  return {
+    platform: spec.platform,
+    format: spec.format,
+    path,
+    case: nameCase ?? spec.defaultCase,
+    ...root !== void 0 ? { root } : {},
+    ...modeSelector !== void 0 ? { modeSelector } : {},
+    ...modes ? { modes } : {}
+  };
+}
+function renderOutput(exp, o, header) {
+  switch (o.format) {
+    case "css":
+      return cssOutput(exp, { ...header, platform: o.platform, format: o.format }, {
+        case: o.case,
+        ...o.root !== void 0 ? { root: o.root } : {},
+        ...o.modeSelector !== void 0 ? { modeSelector: o.modeSelector } : {},
+        ...o.modes ? { modes: o.modes } : {}
+      });
+    default: {
+      const exhaustive = o.format;
+      return exhaustive;
+    }
+  }
+}
+function readIndexImports(cwd, o) {
+  const path = resolve2(cwd, o.path, CSS_INDEX_FILE);
+  let text;
   try {
-    parsed = JSON.parse(readFileSync(path, "utf8"));
+    text = readFileSync3(path, "utf8");
   } catch {
-    throw unreadable();
+    return null;
   }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw unreadable();
-  const record = parsed;
-  if (typeof record.libraryId !== "string" || typeof record.key !== "string") throw unreadable();
-  return { libraryId: record.libraryId, key: record.key };
+  return [...text.matchAll(/^@import "\.\/([^"\n]+)";$/gm)].map((m) => m[1]);
 }
-function writeCredentials(cwd, stored) {
-  const path = join(cwd, CREDENTIALS_NAME);
-  const replaced = existsSync(path);
-  const body = { libraryId: stored.libraryId, key: stored.key };
-  writeFileSync(path, `${JSON.stringify(body, null, 2)}
-`, { mode: 384 });
-  chmodSync(path, 384);
-  return { replaced };
+var LEGACY_CSS_PATH_NOTE = (path) => `${path} names a file; spec-layer 0.7.0 writes a directory. Set outputs[].path to a directory, for example "tokens", delete the old file, and pull again.`;
+function outputPathProblem(cwd, outDir, o, others = []) {
+  if (/\.css$/i.test(o.path)) return LEGACY_CSS_PATH_NOTE(o.path);
+  const marker = specOf(o.platform, o.format)?.headerPrefix ?? CSS_HEADER_PREFIX;
+  return visibleDirProblem(cwd, outDir, o.path, marker, others, "outputs[].path");
 }
 
 // src/config.ts
 var DEFAULT_API = "https://api.spec-layer.com";
 var DEFAULT_OUT_DIR = ".speclayer";
+var DEFAULT_COMPONENT_SPECS_DIR = "component-specs";
 var CONFIG_NAME = "speclayer.json";
 var invalidConfig = () => new Error(`${CONFIG_NAME} is not valid JSON. Fix or delete it, then retry.`);
 function parseInclude(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) throw invalidConfig();
   const record = value;
   if (record.foundation !== void 0 && typeof record.foundation !== "boolean") throw invalidConfig();
-  if (record.components !== void 0 && !(Array.isArray(record.components) && record.components.every((c) => typeof c === "string"))) {
+  if (record.components !== void 0 && record.components !== null && !(Array.isArray(record.components) && record.components.every((c) => typeof c === "string"))) {
     throw invalidConfig();
   }
   return {
     foundation: record.foundation === void 0 ? true : record.foundation,
-    components: record.components === void 0 ? null : record.components
+    components: record.components ?? null
   };
 }
 function parseDtcg(value) {
@@ -2189,12 +3024,39 @@ function parseDtcg(value) {
   }
   return out;
 }
+function parseComponentSpecsDir(value) {
+  if (typeof value !== "string" || value.length === 0) throw new Error('speclayer.json "componentSpecsDir" must be a non-empty string.');
+  let dir = value.replace(/\\/g, "/");
+  if (dir.startsWith("./")) dir = dir.slice(2);
+  dir = dir.replace(/\/+$/, "");
+  if (dir.length === 0) throw new Error('speclayer.json "componentSpecsDir" must be a non-empty string.');
+  return dir;
+}
+function parsePlatforms(value) {
+  if (!Array.isArray(value) || !value.every((p) => typeof p === "string" && isPlatform(p))) {
+    throw new Error(`speclayer.json "platforms" must be an array of ${PLATFORMS.join(", ")}.`);
+  }
+  return [...new Set(value)];
+}
+function parseOutputs(value) {
+  if (!Array.isArray(value)) throw new Error('speclayer.json "outputs" must be an array.');
+  const outputs = value.map((v, i) => parseOutput(v, i));
+  const seen = /* @__PURE__ */ new Set();
+  for (const output of outputs) {
+    const key = `${output.platform}/${output.format}`;
+    if (seen.has(key)) {
+      throw new Error(`speclayer.json "outputs" lists ${output.platform}/${output.format} more than once. Keep one entry per platform and format.`);
+    }
+    seen.add(key);
+  }
+  return outputs;
+}
 function readConfig(cwd) {
-  const path = join2(cwd, CONFIG_NAME);
-  if (!existsSync2(path)) return null;
+  const path = join4(cwd, CONFIG_NAME);
+  if (!existsSync4(path)) return null;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync2(path, "utf8"));
+    parsed = JSON.parse(readFileSync4(path, "utf8"));
   } catch {
     throw invalidConfig();
   }
@@ -2203,24 +3065,30 @@ function readConfig(cwd) {
   return {
     ...typeof record.libraryId === "string" ? { libraryId: record.libraryId } : {},
     ...typeof record.outDir === "string" ? { outDir: record.outDir } : {},
+    ...record.componentSpecsDir !== void 0 ? { componentSpecsDir: parseComponentSpecsDir(record.componentSpecsDir) } : {},
     ...record.include !== void 0 ? { include: parseInclude(record.include) } : {},
-    ...record.dtcg !== void 0 ? { dtcg: parseDtcg(record.dtcg) } : {}
+    ...record.dtcg !== void 0 ? { dtcg: parseDtcg(record.dtcg) } : {},
+    ...record.platforms !== void 0 ? { platforms: parsePlatforms(record.platforms) } : {},
+    ...record.outputs !== void 0 ? { outputs: parseOutputs(record.outputs) } : {}
   };
 }
 function writeConfig(cwd, config) {
   const body = {
     libraryId: config.libraryId,
     outDir: config.outDir,
+    ...config.componentSpecsDir ? { componentSpecsDir: config.componentSpecsDir } : {},
     ...config.include ? { include: config.include } : {},
-    ...config.dtcg ? { dtcg: config.dtcg } : {}
+    ...config.dtcg ? { dtcg: config.dtcg } : {},
+    ...config.platforms && config.platforms.length > 0 ? { platforms: config.platforms } : {},
+    ...config.outputs ? { outputs: config.outputs } : {}
   };
-  writeFileSync2(join2(cwd, CONFIG_NAME), `${JSON.stringify(body, null, 2)}
+  writeFileSync3(join4(cwd, CONFIG_NAME), `${JSON.stringify(body, null, 2)}
 `);
 }
 function resolveOptions(cwd, flags, env, manifestLibraryId) {
   const config = readConfig(cwd);
   const outDir = flags.out ?? config?.outDir ?? DEFAULT_OUT_DIR;
-  const libraryId = flags.id ?? config?.libraryId ?? manifestLibraryId(join2(cwd, outDir));
+  const libraryId = flags.id ?? config?.libraryId ?? manifestLibraryId(join4(cwd, outDir));
   const supplied = flags.key || env.SPEC_LAYER_KEY || null;
   let storedKey = null;
   let storedKeyFor;
@@ -2234,11 +3102,14 @@ function resolveOptions(cwd, flags, env, manifestLibraryId) {
   return {
     libraryId,
     outDir,
+    componentSpecsDir: config?.componentSpecsDir ?? DEFAULT_COMPONENT_SPECS_DIR,
     // A trailing slash would build "//v1/..." paths the proxy router 404s on.
     api: (flags.api ?? env.SPEC_LAYER_API ?? DEFAULT_API).replace(/\/+$/, ""),
     key: supplied ?? storedKey,
     ...config?.include ? { include: config.include } : {},
     ...config?.dtcg ? { dtcg: config.dtcg } : {},
+    ...config?.platforms ? { platforms: config.platforms } : {},
+    ...config?.outputs ? { outputs: config.outputs } : {},
     ...storedKeyFor ? { storedKeyFor } : {}
   };
 }
@@ -2277,8 +3148,8 @@ async function fetchBundle(opts) {
 }
 
 // src/files.ts
-import { mkdirSync, writeFileSync as writeFileSync3, readFileSync as readFileSync3, readdirSync, rmSync, renameSync, existsSync as existsSync3 } from "node:fs";
-import { join as join3, dirname, relative, resolve, isAbsolute } from "node:path";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync4, readFileSync as readFileSync5, readdirSync as readdirSync3, rmSync as rmSync2, renameSync as renameSync2, existsSync as existsSync5 } from "node:fs";
+import { join as join5, dirname, relative as relative2, resolve as resolve3, isAbsolute as isAbsolute2, sep } from "node:path";
 
 // src/selection.ts
 var DEFAULT_SELECTION = { foundation: true, components: null };
@@ -2316,20 +3187,29 @@ function slugify(name) {
   const slug2 = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
   return slug2 || "component";
 }
+var COMPONENT_SPEC_MARKER = "spec_layer:\n  kind: component";
 function readManifest(outDir) {
-  const path = join3(outDir, "manifest.json");
-  if (!existsSync3(path)) return null;
+  const path = join5(outDir, "manifest.json");
+  if (!existsSync5(path)) return null;
   try {
-    return JSON.parse(readFileSync3(path, "utf8"));
+    const parsed = JSON.parse(readFileSync5(path, "utf8"));
+    parsed.artifacts = parsed.artifacts.map((artifact) => {
+      const { aiPath, ...rest } = artifact;
+      return {
+        ...rest,
+        path: rest.path ?? aiPath ?? null
+      };
+    });
+    return parsed;
   } catch {
     return null;
   }
 }
 function readLocalBundle(outDir) {
-  const path = join3(outDir, "bundle.json");
-  if (!existsSync3(path)) return null;
+  const path = join5(outDir, "bundle.json");
+  if (!existsSync5(path)) return null;
   try {
-    return parseBundle(readFileSync3(path, "utf8"));
+    return parseBundle(readFileSync5(path, "utf8"));
   } catch {
     throw new Error(`${path} could not be read as a library bundle. Run spec-layer pull again.`);
   }
@@ -2356,11 +3236,11 @@ function componentSlugs(bundle) {
   });
 }
 function assertReplaceable(outDir, cwd) {
-  const rel = relative(resolve(cwd), resolve(outDir));
-  if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) {
+  const rel = relative2(resolve3(cwd), resolve3(outDir));
+  if (rel === "" || rel.startsWith("..") || isAbsolute2(rel)) {
     throw new Error('The output directory must sit inside the current directory, not be "." or a parent of it.');
   }
-  if (existsSync3(outDir) && !existsSync3(join3(outDir, "manifest.json")) && readdirSync(outDir).length > 0) {
+  if (existsSync5(outDir) && !existsSync5(join5(outDir, "manifest.json")) && readdirSync3(outDir).length > 0) {
     throw new Error(`${outDir} exists and was not written by spec-layer pull. Choose an empty or new directory.`);
   }
 }
@@ -2369,44 +3249,70 @@ function writeBundleFiles(opts) {
   const selection = opts.selection ?? DEFAULT_SELECTION;
   const selected = selectComponents(opts.bundle, selection);
   const slugs = componentSlugs(opts.bundle);
+  const outputs = opts.outputs ?? [];
+  const componentSpecsDir = opts.componentSpecsDir ?? DEFAULT_COMPONENT_SPECS_DIR;
+  const outDirRel = relative2(resolve3(opts.cwd), resolve3(opts.outDir)).split(sep).join("/");
+  const outputPaths = outputs.map((o) => o.path);
+  const specsProblem = visibleDirProblem(opts.cwd, outDirRel, componentSpecsDir, COMPONENT_SPEC_MARKER, outputPaths, "componentSpecsDir");
+  if (specsProblem) throw new Error(specsProblem);
+  for (const o of outputs) {
+    const problem = outputPathProblem(opts.cwd, outDirRel, o, [componentSpecsDir, ...outputPaths.filter((p) => p !== o.path)]);
+    if (problem) throw new Error(problem);
+  }
+  const briefs = {};
+  opts.bundle.components.forEach((component, i) => {
+    if (!selected[i]) return;
+    if (!component.ai.startsWith(COMPONENT_SPEC_MARKER)) {
+      throw new Error(`The published brief for ${component.name} does not begin with the Spec Layer marker. Republish from the plugin, then pull again.`);
+    }
+    briefs[`${slugs[i]}.yaml`] = component.ai;
+  });
   const staging = `${opts.outDir}.partial`;
-  rmSync(staging, { recursive: true, force: true });
+  rmSync2(staging, { recursive: true, force: true });
   const written = [];
+  const deliverables = [];
+  const json = (v) => `${JSON.stringify(v, null, 2)}
+`;
   const put = (rel, content) => {
-    const path = join3(staging, rel);
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync3(path, content);
+    const path = join5(staging, rel);
+    mkdirSync2(dirname(path), { recursive: true });
+    writeFileSync4(path, content);
     written.push(rel);
   };
   try {
     put("bundle.json", opts.raw);
     const artifacts = [];
     if (opts.bundle.foundation) {
-      let aiPath = null;
+      let path = null;
       if (selection.foundation) {
         const artifact = opts.bundle.foundation.artifact;
         if (validateLevel1(artifact).some((d) => d.severity === "error")) {
           throw new Error("The published Foundation context did not pass schema validation. Republish from the plugin, then pull again.");
         }
-        const files = dtcgExportFiles(foundationDtcg(artifact, opts.dtcg ?? {}));
-        for (const [name, text] of Object.entries(files)) put(`tokens/${name}`, text);
-        aiPath = "tokens/resolver.json";
+        const exp = foundationDtcg(artifact, opts.dtcg ?? {});
+        for (const [name, text] of Object.entries(dtcgExportFiles(exp))) put(`tokens/${name}`, text);
+        path = `${outDirRel}/tokens/resolver.json`;
+        const header = { libraryId: opts.libraryId, contentHash: opts.bundle.foundation.artifact.spec_layer.export.content_hash };
+        for (const output of outputs) {
+          const rendered = renderOutput(exp, output, header);
+          put(`outputs/${outputId(output)}.map.json`, json(rendered.map));
+          put(`outputs/${outputId(output)}.report.json`, json(rendered.report));
+          deliverables.push({ output, files: rendered.files });
+        }
       }
       artifacts.push({
         kind: "foundation",
         name: "foundation",
         contentHash: opts.bundle.foundation.artifact.spec_layer.export.content_hash,
-        aiPath
+        path
       });
     }
     opts.bundle.components.forEach((component, i) => {
-      const aiPath = selected[i] ? `ai/components/${slugs[i]}.yaml` : null;
-      if (aiPath) put(aiPath, component.ai);
       artifacts.push({
         kind: "component",
         name: component.name,
         contentHash: component.artifact.spec_layer.export.content_hash,
-        aiPath
+        path: selected[i] ? `${componentSpecsDir}/${slugs[i]}.yaml` : null
       });
     });
     const manifest = {
@@ -2416,24 +3322,31 @@ function writeBundleFiles(opts) {
       pluginVersion: opts.bundle.pluginVersion,
       extractorVersion: opts.bundle.extractorVersion,
       selection,
+      componentSpecsDir,
       artifacts,
-      ...opts.dtcg && Object.keys(opts.dtcg).length > 0 ? { dtcg: opts.dtcg } : {}
+      ...opts.dtcg && Object.keys(opts.dtcg).length > 0 ? { dtcg: opts.dtcg } : {},
+      ...opts.platforms && opts.platforms.length > 0 ? { platforms: opts.platforms } : {},
+      ...opts.outputs ? { outputs: opts.outputs } : {}
     };
-    put("manifest.json", `${JSON.stringify(manifest, null, 2)}
-`);
+    put("manifest.json", json(manifest));
   } catch (err) {
-    rmSync(staging, { recursive: true, force: true });
+    rmSync2(staging, { recursive: true, force: true });
     throw err;
   }
-  rmSync(opts.outDir, { recursive: true, force: true });
-  renameSync(staging, opts.outDir);
-  return written;
+  rmSync2(opts.outDir, { recursive: true, force: true });
+  renameSync2(staging, opts.outDir);
+  const componentSpecs = { path: componentSpecsDir, files: writeVisibleDir(opts.cwd, componentSpecsDir, COMPONENT_SPEC_MARKER, briefs) };
+  const outputResults = [];
+  for (const d of deliverables) {
+    outputResults.push({ path: d.output.path, files: writeVisibleDir(opts.cwd, d.output.path, CSS_HEADER_PREFIX, d.files, CSS_INDEX_FILE) });
+  }
+  return { written, componentSpecs, outputs: outputResults };
 }
 
 // src/gitignore.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync4 } from "node:fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync6 } from "node:fs";
 import { spawnSync } from "node:child_process";
-import { join as join4, dirname as dirname2, resolve as resolve2 } from "node:path";
+import { join as join6, dirname as dirname2, resolve as resolve4 } from "node:path";
 var COMMENT = "# Spec Layer pull key, not for committing";
 function git(cwd, args) {
   const res = spawnSync("git", args, { cwd, stdio: ["ignore", "pipe", "ignore"], encoding: "utf8" });
@@ -2441,9 +3354,9 @@ function git(cwd, args) {
   return { ranGit: true, status: res.status, stdout: res.stdout ?? "" };
 }
 function insideWorkTreeWithoutGit(cwd) {
-  let dir = resolve2(cwd);
+  let dir = resolve4(cwd);
   for (; ; ) {
-    if (existsSync4(join4(dir, ".git"))) return true;
+    if (existsSync6(join6(dir, ".git"))) return true;
     const parent = dirname2(dir);
     if (parent === dir) return false;
     dir = parent;
@@ -2460,18 +3373,18 @@ function ensureIgnored(cwd, fileName) {
   if (inWorkTree.status !== 0 || inWorkTree.stdout.trim() !== "true") return { kind: "not-a-repo" };
   const checkIgnore = git(cwd, ["check-ignore", "-q", fileName]);
   if (checkIgnore.ranGit && checkIgnore.status === 0) return { kind: "already" };
-  const path = join4(cwd, ".gitignore");
-  const existed = existsSync4(path);
+  const path = join6(cwd, ".gitignore");
+  const existed = existsSync6(path);
   try {
     if (!existed) {
-      writeFileSync4(path, `${COMMENT}
+      writeFileSync5(path, `${COMMENT}
 ${fileName}
 `);
     } else {
-      const body = readFileSync4(path, "utf8");
+      const body = readFileSync6(path, "utf8");
       if (!hasEntryLine(body, fileName)) {
         const lead = body.length === 0 || body.endsWith("\n") ? "" : "\n";
-        writeFileSync4(path, `${body}${lead}${COMMENT}
+        writeFileSync5(path, `${body}${lead}${COMMENT}
 ${fileName}
 `);
       }
@@ -2484,158 +3397,9 @@ ${fileName}
   return existed ? { kind: "added" } : { kind: "created" };
 }
 
-// src/detect.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync5 } from "node:fs";
-import { join as join5 } from "node:path";
-var CODE_SYNTAX_KEY = {
-  web: "WEB",
-  ios: "iOS",
-  android: "ANDROID",
-  flutter: null
-};
-var PLATFORMS = ["web", "ios", "android", "flutter"];
-var AGENT_HOSTS = ["claude", "cursor", "copilot", "windsurf", "gemini", "agents-md"];
-var uniq = (xs) => [...new Set(xs)];
-function readPackageJson(cwd) {
-  const path = join5(cwd, "package.json");
-  if (!existsSync5(path)) return null;
-  let parsed;
-  try {
-    parsed = JSON.parse(readFileSync5(path, "utf8"));
-  } catch {
-    return null;
-  }
-  if (typeof parsed !== "object" || parsed === null) return null;
-  const record = parsed;
-  const deps = {};
-  for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
-    const block = record[field];
-    if (typeof block !== "object" || block === null) continue;
-    for (const [name, range] of Object.entries(block)) {
-      if (typeof range === "string") deps[name] = range;
-    }
-  }
-  return { deps };
-}
-function majorOf(range) {
-  const m = /^[\^~>=<\s]*v?(\d+)/.exec(range.trim());
-  return m ? Number(m[1]) : null;
-}
-var DEP_SIGNALS = [
-  { dep: "react", platform: "web", framework: "react" },
-  { dep: "next", platform: "web", framework: "next" },
-  { dep: "vue", platform: "web", framework: "vue" },
-  { dep: "nuxt", platform: "web", framework: "nuxt" },
-  { dep: "svelte", platform: "web", framework: "svelte" },
-  { dep: "@sveltejs/kit", platform: "web", framework: "sveltekit" },
-  { dep: "@angular/core", platform: "web", framework: "angular" },
-  { dep: "solid-js", platform: "web", framework: "solid" },
-  { dep: "lit", platform: "web", framework: "lit" },
-  { dep: "astro", platform: "web", framework: "astro" },
-  { dep: "react-native", platform: "ios", framework: "react-native" },
-  { dep: "expo", platform: "ios", framework: "expo" },
-  { dep: "tailwindcss", platform: "web", tokenTool: "tailwind" },
-  { dep: "styled-components", platform: "web", framework: "styled-components" },
-  { dep: "@emotion/react", platform: "web", framework: "emotion" },
-  { dep: "sass", platform: "web", framework: "sass" },
-  { dep: "@vanilla-extract/css", platform: "web", framework: "vanilla-extract" },
-  { dep: "@stitches/react", platform: "web", framework: "stitches" },
-  { dep: "@pandacss/dev", platform: "web", framework: "panda" },
-  { dep: "style-dictionary", tokenTool: "style-dictionary" },
-  { dep: "@tokens-studio/sd-transforms", tokenTool: "tokens-studio" },
-  { dep: "typescript", language: "typescript" }
-];
-var FILE_SIGNALS = [
-  { test: (n) => n === "Package.swift", signal: "Swift package", platform: "ios", language: "swift" },
-  { test: (n) => n.endsWith(".xcodeproj") || n.endsWith(".xcworkspace"), signal: "Xcode project", platform: "ios", language: "swift" },
-  { test: (n) => n === "Podfile", signal: "CocoaPods", platform: "ios" },
-  { test: (n) => /^build\.gradle(\.kts)?$/.test(n) || /^settings\.gradle(\.kts)?$/.test(n), signal: "Gradle build", platform: "android", language: "kotlin" },
-  { test: (n) => n === "AndroidManifest.xml", signal: "Android manifest", platform: "android" },
-  { test: (n) => n === "pubspec.yaml", signal: "Flutter or Dart package", platform: "flutter", language: "dart" },
-  { test: (n) => n === "tsconfig.json", signal: "TypeScript config", language: "typescript" },
-  { test: (n) => n === "package.json", signal: "npm package", language: "javascript" },
-  { test: (n) => n === "deno.json" || n === "deno.jsonc", signal: "Deno config", language: "typescript" },
-  { test: (n) => n === "Cargo.toml", signal: "Cargo manifest", language: "rust" },
-  { test: (n) => n === "go.mod", signal: "Go module", language: "go" },
-  { test: (n) => n === "pyproject.toml" || n === "requirements.txt", signal: "Python project", language: "python" },
-  { test: (n) => n === "Gemfile", signal: "Ruby bundle", language: "ruby" },
-  { test: (n) => n === "composer.json", signal: "Composer package", language: "php" },
-  { test: (n) => n.endsWith(".csproj") || n.endsWith(".sln"), signal: ".NET project", language: "csharp" },
-  { test: (n) => n === "pom.xml", signal: "Maven build", language: "java" },
-  { test: (n) => /^tailwind\.config\.(js|cjs|mjs|ts)$/.test(n), signal: "Tailwind config", platform: "web", tokenTool: "tailwind" },
-  { test: (n) => /^(style-dictionary\.config|sd\.config)\.(js|cjs|mjs|ts|json)$/.test(n), signal: "Style Dictionary config", tokenTool: "style-dictionary" },
-  { test: (n) => n === "index.html" || n === "vite.config.ts" || n === "vite.config.js", signal: "web entry", platform: "web" },
-  { test: (n) => n === "CLAUDE.md" || n === ".claude", signal: "Claude Code", agent: "claude" },
-  { test: (n) => n === ".cursor" || n === ".cursorrules", signal: "Cursor", agent: "cursor" },
-  { test: (n) => n === ".windsurf" || n === ".windsurfrules", signal: "Windsurf", agent: "windsurf" },
-  { test: (n) => n === "GEMINI.md", signal: "Gemini CLI", agent: "gemini" },
-  { test: (n) => n === "AGENTS.md", signal: "AGENTS.md", agent: "agents-md" }
-];
-function detectRepo(cwd) {
-  const platforms = [];
-  const languages = [];
-  const frameworks = [];
-  const tokenTools = [];
-  const agents = [];
-  const evidence = [];
-  let styleDictionaryMajor = null;
-  let names = [];
-  try {
-    names = readdirSync2(cwd).sort();
-  } catch {
-    names = [];
-  }
-  for (const name of names) {
-    for (const rule of FILE_SIGNALS) {
-      if (!rule.test(name)) continue;
-      evidence.push({ signal: rule.signal, file: name });
-      if (rule.platform) platforms.push(rule.platform);
-      if (rule.language) languages.push(rule.language);
-      if (rule.framework) frameworks.push(rule.framework);
-      if (rule.tokenTool) tokenTools.push(rule.tokenTool);
-      if (rule.agent) agents.push(rule.agent);
-    }
-  }
-  if (existsSync5(join5(cwd, ".github", "copilot-instructions.md")) || existsSync5(join5(cwd, ".github", "instructions"))) {
-    evidence.push({ signal: "GitHub Copilot", file: ".github/copilot-instructions.md" });
-    agents.push("copilot");
-  }
-  const pkg = readPackageJson(cwd);
-  if (pkg) {
-    for (const rule of DEP_SIGNALS) {
-      const range = pkg.deps[rule.dep];
-      if (range === void 0) continue;
-      evidence.push({ signal: `${rule.dep} dependency`, file: "package.json" });
-      if (rule.platform) platforms.push(rule.platform);
-      if (rule.framework) frameworks.push(rule.framework);
-      if (rule.tokenTool) tokenTools.push(rule.tokenTool);
-      if (rule.language) languages.push(rule.language);
-      if (rule.dep === "style-dictionary") styleDictionaryMajor = majorOf(range);
-    }
-    if (pkg.deps["react-native"] !== void 0 || pkg.deps.expo !== void 0) platforms.push("android");
-  }
-  const order = (p) => PLATFORMS.indexOf(p);
-  const hostOrder = (a) => AGENT_HOSTS.indexOf(a);
-  return {
-    platforms: uniq(platforms).sort((a, b) => order(a) - order(b)),
-    languages: uniq(languages).sort(),
-    frameworks: uniq(frameworks).sort(),
-    tokenTools: uniq(tokenTools).sort(),
-    agents: uniq(agents).sort((a, b) => hostOrder(a) - hostOrder(b)),
-    styleDictionaryMajor,
-    evidence
-  };
-}
-function isPlatform(value) {
-  return PLATFORMS.includes(value);
-}
-function isAgentHost(value) {
-  return AGENT_HOSTS.includes(value);
-}
-
 // src/skill.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname3, join as join6 } from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readdirSync as readdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname3, join as join7 } from "node:path";
 
 // src/tools.ts
 var OK_OR_ERROR = { "0": "success", "1": "usage error, bad key or id, or a network or server failure" };
@@ -2643,18 +3407,25 @@ var LOCAL_ONLY = { "0": "success", "1": "no local pull, or a usage error" };
 var TOOLS = [
   {
     name: "setup",
-    usage: "spec-layer setup --id lib_... --key sl_... [--out DIR] [--only foundation|components] [--component NAME]...",
+    usage: "spec-layer setup --id lib_... --key sl_... [--out DIR] [--platform web|ios|android|flutter]... [--only foundation|components] [--component NAME]...",
     summary: "Records the library id, stores the pull key in a gitignored speclayer.local.json, then pulls.",
     when: "Once, with the command the plugin's Publish screen hands out. Re-run it after the key is rotated.",
     network: true,
     needsKey: true,
-    writes: ["speclayer.json", "speclayer.local.json", ".gitignore (one line, when inside a git repo)", "<outDir>/"],
+    writes: [
+      "speclayer.json",
+      "speclayer.local.json",
+      ".gitignore (one line, when inside a git repo)",
+      "<outDir>/",
+      "outputs[].path from speclayer.json (default tokens/ for web), a directory written in place",
+      "componentSpecsDir from speclayer.json (default component-specs/), written in place"
+    ],
     exits: OK_OR_ERROR
   },
   {
     name: "init",
-    usage: "spec-layer init --id lib_... [--out DIR] [--only foundation|components] [--component NAME]...",
-    summary: "Writes speclayer.json so later commands need no flags. Stores no key and reaches no server.",
+    usage: "spec-layer init --id lib_... [--out DIR] [--platform web|ios|android|flutter]... [--only foundation|components] [--component NAME]...",
+    summary: "Writes speclayer.json, with the platforms and default outputs, so later commands need no flags. Stores no key and reaches no server.",
     when: "A repo that supplies the key from SPEC_LAYER_KEY instead of a stored file.",
     network: false,
     needsKey: false,
@@ -2663,12 +3434,16 @@ var TOOLS = [
   },
   {
     name: "pull",
-    usage: "spec-layer pull [--id lib_...] [--key sl_...] [--out DIR] [--only foundation|components] [--component NAME]...",
-    summary: "Fetches the published library and writes it under the output directory (default .speclayer/).",
-    when: "After setup, whenever status says the local copy is behind, or after changing the include or dtcg block.",
+    usage: "spec-layer pull [--id lib_...] [--key sl_...] [--out DIR] [--platform web|ios|android|flutter]... [--only foundation|components] [--component NAME]...",
+    summary: "Fetches the published library and writes the record under the output directory (default .speclayer/), the briefs under componentSpecsDir, and the token files under outputs[].path.",
+    when: "After setup, whenever status says the local copy is behind, or after changing the include, dtcg, outputs, or componentSpecsDir blocks.",
     network: true,
     needsKey: true,
-    writes: ["<outDir>/"],
+    writes: [
+      "<outDir>/",
+      "outputs[].path from speclayer.json (default tokens/ for web), a directory written in place",
+      "componentSpecsDir from speclayer.json (default component-specs/), written in place"
+    ],
     exits: OK_OR_ERROR
   },
   {
@@ -2713,7 +3488,7 @@ var TOOLS = [
   },
   {
     name: "skill",
-    usage: "spec-layer skill [--install] [--agent claude|cursor|copilot|windsurf|gemini|agents-md]... [--platform web|ios|android|flutter] [--json] [--out DIR]",
+    usage: "spec-layer skill [--install] [--agent claude|cursor|copilot|windsurf|gemini|agents-md]... [--platform web|ios|android|flutter]... [--json] [--out DIR]",
     summary: "Prints a guide for a coding agent, adapted to this repository's stack and to the last pull; --install writes it where the agent reads instructions.",
     when: "Right after setup, and again after a pull that adds components or after the codebase changes stack.",
     network: false,
@@ -2768,42 +3543,42 @@ function countNumberTokens(tree) {
   return n;
 }
 function readJson(path) {
-  if (!existsSync6(path)) return null;
+  if (!existsSync7(path)) return null;
   try {
-    return JSON.parse(readFileSync6(path, "utf8"));
+    return JSON.parse(readFileSync7(path, "utf8"));
   } catch {
     return null;
   }
 }
 function summarizePull(cwd, outDir, manifest) {
   if (!manifest) return null;
-  const absOut = join6(cwd, outDir);
-  const components = manifest.artifacts.filter((a) => a.kind === "component").map((a) => ({ name: a.name, path: a.aiPath ? `${outDir}/${a.aiPath}` : null }));
+  const absOut = join7(cwd, outDir);
+  const components = manifest.artifacts.filter((a) => a.kind === "component").map((a) => ({ name: a.name, path: a.path }));
   const foundationEntry = manifest.artifacts.find((a) => a.kind === "foundation") ?? null;
   let foundation = null;
   if (foundationEntry) {
-    const tokensDir = join6(absOut, "tokens");
-    const resolver = readJson(join6(tokensDir, "resolver.json"));
-    const report = readJson(join6(tokensDir, "report.json"));
+    const tokensDir = join7(absOut, "tokens");
+    const resolver = readJson(join7(tokensDir, "resolver.json"));
+    const report2 = readJson(join7(tokensDir, "report.json"));
     let tokenFiles = [];
     try {
-      tokenFiles = readdirSync3(tokensDir).filter((f) => f.endsWith(".json") && !RESERVED.has(f)).sort();
+      tokenFiles = readdirSync4(tokensDir).filter((f) => f.endsWith(".json") && !RESERVED.has(f)).sort();
     } catch {
       tokenFiles = [];
     }
     let unitlessNumbers = 0;
     for (const file of tokenFiles) {
       if (file.startsWith("styles.")) continue;
-      unitlessNumbers += countNumberTokens(readJson(join6(tokensDir, file)));
+      unitlessNumbers += countNumberTokens(readJson(join7(tokensDir, file)));
     }
     const reportCounts = {};
-    if (Array.isArray(report)) {
-      for (const entry2 of report) {
+    if (Array.isArray(report2)) {
+      for (const entry2 of report2) {
         if (typeof entry2?.code === "string") reportCounts[entry2.code] = (reportCounts[entry2.code] ?? 0) + 1;
       }
     }
     foundation = {
-      written: foundationEntry.aiPath !== null && resolver !== null,
+      written: foundationEntry.path !== null && resolver !== null,
       sets: resolver ? Object.keys(resolver.sets ?? {}) : [],
       modifiers: resolver ? Object.entries(resolver.modifiers ?? {}).map(([name, m]) => ({
         name,
@@ -2820,8 +3595,33 @@ function summarizePull(cwd, outDir, manifest) {
     libraryId: manifest.libraryId,
     publishedAt: manifest.publishedAt,
     pluginVersion: manifest.pluginVersion,
+    componentSpecsDir: manifest.componentSpecsDir ?? DEFAULT_COMPONENT_SPECS_DIR,
     components,
-    foundation
+    foundation,
+    outputs: (manifest.outputs ?? []).map((o) => {
+      const mapPath = join7(absOut, "outputs", `${o.platform}-${o.format}.map.json`);
+      const map = readJson(mapPath);
+      const imports = map ? readIndexImports(cwd, o) : null;
+      const files = imports !== null ? [...imports, CSS_INDEX_FILE] : [];
+      return {
+        platform: o.platform,
+        format: o.format,
+        path: o.path,
+        case: o.case,
+        modeSelector: o.modeSelector ?? '[data-theme="{mode}"]',
+        modes: o.modes ?? {},
+        // index.css must be readable, not just the map, or a deleted index.css
+        // (with the map still on disk from an interrupted pull) would report
+        // written with an empty file list, a sentence that claims files exist.
+        written: map !== null && imports !== null,
+        // Distinguishes "the map is on disk but index.css is gone" from "the
+        // map itself never existed" (the Foundation was excluded), so the
+        // guide can name the actual cause instead of always blaming the
+        // Foundation.
+        indexMissing: map !== null && imports === null,
+        files
+      };
+    })
   };
 }
 var code = (s) => `\`${s}\``;
@@ -2848,7 +3648,7 @@ function stackSection(input) {
       ""
     );
   } else {
-    const label = platformSource === "flag" ? "chosen with --platform" : "detected";
+    const label = platformSource === "flag" ? "chosen with --platform" : platformSource === "config" ? "set in speclayer.json" : "detected";
     lines.push(`Target platform${platforms.length > 1 ? "s" : ""} (${label}): ${platforms.join(", ")}.`, "");
   }
   for (const platform of platforms) {
@@ -2856,10 +3656,47 @@ function stackSection(input) {
     const tokensDir = `${input.outDir}/tokens/`;
     if (platform === "web") {
       lines.push("### Web", "");
-      lines.push(
-        `Token identifiers for code live in ${code(`${tokensDir}spec-layer.meta.json`)} under each token's ${code("code_syntax.WEB")}, when the designer declared one in Figma. Use that identifier as the CSS custom property or theme key. When a token has no WEB entry, derive nothing: use the DTCG path as it appears in the token file (for example ${code("{Collection.group.name}")}) and say in your change that the code name is not declared in Figma.`
-      );
-      lines.push("");
+      const cssOut = pull?.outputs.find((o) => o.platform === "web" && o.format === "css" && o.written) ?? null;
+      if (cssOut) {
+        const mapPath = `${input.outDir}/outputs/web-css.map.json`;
+        lines.push(
+          `The CSS custom property for every token is in ${code(mapPath)}: source "code_syntax" when the designer declared it in Figma, "derived" when the CLI built it from the DTCG path by the stated rule (${cssOut.case} case, collection root included). Each entry names the file that declares the property. Use those names; never invent a third. ${code(`${tokensDir}spec-layer.meta.json`)} still holds the raw ${code("code_syntax.WEB")} the designer declared.`,
+          ""
+        );
+        const partFiles = cssOut.files.filter((f) => f !== CSS_INDEX_FILE);
+        lines.push(
+          `Import ${code(`${cssOut.path}/index.css`)} from the root stylesheet. It imports one file per collection and mode: ${partFiles.join(", ")}. Sets and default modes are at ${code(":root")}; every other mode is a block under ${code(cssOut.modeSelector)} in its own file, so a mode can also be imported alone. To switch, set ${code("data-theme")} on ${code("<html>")} (or whatever the selector names). To let the OS choose, set that collection's selector to ${code(":root")} under ${code("outputs[].modes")} and import the mode's file yourself under ${code("@media (prefers-color-scheme: dark)")}; the CLI never assumes that.`,
+          ""
+        );
+        if (profile.tokenTools.includes("style-dictionary") || profile.tokenTools.includes("tokens-studio")) {
+          lines.push(
+            `${code(`${cssOut.path}/`)} is a projection of the same ${code(tokensDir)} files, not a second source. Import one or the other.`,
+            ""
+          );
+        }
+      } else {
+        lines.push(
+          `Token identifiers for code live in ${code(`${tokensDir}spec-layer.meta.json`)} under each token's ${code(`code_syntax.${key}`)}, when the designer declared one in Figma. When a token has no WEB entry, use the DTCG path as it appears in the token file and say in your change that the code name is not declared in Figma.`,
+          ""
+        );
+        const configuredNotWritten = pull?.outputs.find((o) => o.platform === "web" && !o.written) ?? null;
+        if (configuredNotWritten?.indexMissing) {
+          lines.push(
+            `A web/css output is configured at ${code(`${configuredNotWritten.path}/`)} but its ${code("index.css")} is missing, so the file list is unknown. Run ${code("npx spec-layer pull")} to write it again.`,
+            ""
+          );
+        } else if (configuredNotWritten) {
+          lines.push(
+            `A web/css output is configured at ${code(`${configuredNotWritten.path}/`)} but was not written, because the last pull did not write the Foundation. Pull with the Foundation selected to write it.`,
+            ""
+          );
+        } else if (pull?.foundation?.written) {
+          lines.push(
+            `No token file was written for web. Add \`"outputs"\` in \`speclayer.json\` (or run \`spec-layer pull --platform web\` once) and pull again; the default lands at ${code("tokens/")}.`,
+            ""
+          );
+        }
+      }
       if (profile.tokenTools.includes("tailwind")) {
         lines.push(
           `Tailwind is present (${code("tailwindcss")}). Map DTCG ${code("color")} tokens to the theme's color scale and ${code("dimension")} tokens to spacing, radius, or font size by the collection and group they sit in. Keep the mapping in one place and reference token paths, not copied values, so a republish moves the code with it.`,
@@ -2937,7 +3774,10 @@ function pullSection(input) {
   } else {
     lines.push("- This library has no Foundation, so there is no tokens/ directory.");
   }
-  lines.push(`- ${code(`${outDir}/ai/components/`)}: one YAML per component.`);
+  lines.push(`- ${code(`${pull.componentSpecsDir}/`)}: one YAML per component.`);
+  for (const o of pull.outputs) {
+    lines.push(o.written ? `- ${code(`${o.path}/`)}: ${o.platform}/${o.format} token files, ${o.case} names: ${o.files.join(", ")}. Non-default modes are under ${code(o.modeSelector)}, each in its own file. Names and provenance: ${code(`${outDir}/outputs/${o.platform}-${o.format}.map.json`)}; what it could not express: ${code(`${outDir}/outputs/${o.platform}-${o.format}.report.json`)}.` : o.indexMissing ? `- ${code(`${o.path}/`)}: ${o.platform}/${o.format} token files, but ${code("index.css")} is missing; run ${code("npx spec-layer pull")} to restore the directory.` : `- ${code(`${o.path}/`)}: ${o.platform}/${o.format} token files, configured but not written by the last pull (the Foundation was not written). Nothing is on disk at that path from Spec Layer.`);
+  }
   lines.push("");
   if (pull.foundation && (pull.foundation.sets.length || pull.foundation.modifiers.length)) {
     lines.push("### Token collections", "");
@@ -2991,18 +3831,21 @@ function buildSkillGuide(input) {
     `The Spec Layer Figma plugin publishes a design system's components, variables, and styles as data. The ${code("spec-layer")} CLI (version ${input.version}) pulls that data into this repository under ${code(outDir + "/")}. Everything in those files is extracted deterministically from Figma and validated against a published schema; no model wrote any of it. Treat it as the source of truth for what the design system contains, and treat anything it does not state as unknown rather than as something to infer.`,
     ""
   );
+  const componentSpecsDir = input.pull?.componentSpecsDir ?? input.config?.componentSpecsDir ?? DEFAULT_COMPONENT_SPECS_DIR;
   lines.push("## How to use it", "");
   lines.push(`1. Run ${code("npx spec-layer status")}. Exit 0 means the local copy is current; exit 2 means run ${code("npx spec-layer pull")} first.`);
-  lines.push(`2. Building or changing a component: read its YAML under ${code(`${outDir}/ai/components/`)}, or ${code("npx spec-layer show component NAME")}. ${code("api")} gives variants, states, booleans, and slots; ${code("anatomy")} names the parts; ${code("references.bindings")} says which token each part's property uses and under which ${code("when")} conditions; ${code("unbound")} lists values that are hardcoded in Figma.`);
+  lines.push(`2. Building or changing a component: read its YAML under ${code(`${componentSpecsDir}/`)}, or ${code("npx spec-layer show component NAME")}. ${code("api")} gives variants, states, booleans, and slots; ${code("anatomy")} names the parts; ${code("references.bindings")} says which token each part's property uses and under which ${code("when")} conditions; ${code("unbound")} lists values that are hardcoded in Figma.`);
   lines.push(`3. Working with colors, spacing, type, or effects: start at ${code(`${outDir}/tokens/resolver.json`)}, load the set and mode files it names, and look up ${code("code_syntax")} in ${code("spec-layer.meta.json")} for the name the designer declared for your platform.`);
   lines.push(`4. Reference tokens by name in code; never paste a resolved value where a token exists. A value the design system does not define is not a token: say so in your change rather than adding one.`);
   lines.push(`5. An ${code("unbound")} entry is design debt reported from Figma. Do not silently promote it to a token; keep the literal and note that Figma has no binding for it.`);
-  lines.push(`6. Never edit files under ${code(outDir + "/")}: the next pull replaces the whole directory. Configuration lives in ${code("speclayer.json")}. Never commit ${code(CREDENTIALS_NAME)}, and never print or copy the pull key.`);
+  const writtenOutputs = input.pull?.outputs.filter((o) => o.written) ?? [];
+  const outputNote = writtenOutputs.length ? ` Never edit ${writtenOutputs.map((o) => code(`${o.path}/`)).join(", ")} either: pull replaces or removes files there.` : "";
+  lines.push(`6. Never edit files under ${code(outDir + "/")} or ${code(componentSpecsDir + "/")}: the next pull replaces or removes them.${outputNote} Configuration lives in ${code("speclayer.json")}. Never commit ${code(CREDENTIALS_NAME)}, and never print or copy the pull key.`);
   lines.push("");
   lines.push(...pullSection(input));
   lines.push(...stackSection(input));
   lines.push(...commandsSection());
-  lines.push(`Generated by ${code("spec-layer skill")}. Re-run ${code("npx spec-layer skill --install")} after a pull that adds components or when the codebase changes stack; the file is replaced, not appended.`);
+  lines.push(`Generated by ${code("spec-layer skill")}. Re-run ${code("npx spec-layer skill --install")} after a pull that adds components, after changing ${code("outputs")} or ${code("componentSpecsDir")}, or when the codebase changes stack; the file is replaced, not appended.`);
   return `${lines.join("\n")}
 `;
 }
@@ -3072,25 +3915,25 @@ ${BLOCK_END}
     const after = existing.slice(end + BLOCK_END.length).replace(/^\n/, "");
     return `${existing.slice(0, begin)}${block}${after}`;
   }
-  const sep = existing.length === 0 ? "" : existing.endsWith("\n\n") ? "" : existing.endsWith("\n") ? "\n" : "\n\n";
-  return `${existing}${sep}${block}`;
+  const sep2 = existing.length === 0 ? "" : existing.endsWith("\n\n") ? "" : existing.endsWith("\n") ? "\n" : "\n\n";
+  return `${existing}${sep2}${block}`;
 }
 function installSkill(cwd, host, guide) {
   const target = installTarget(host);
-  const abs = join6(cwd, target.path);
-  const existing = existsSync6(abs) ? readFileSync6(abs, "utf8") : null;
+  const abs = join7(cwd, target.path);
+  const existing = existsSync7(abs) ? readFileSync7(abs, "utf8") : null;
   const next = target.mode === "file" ? renderForHost(host, guide) : upsertBlock(existing, renderForHost(host, guide));
   if (existing === next) return { path: target.path, result: "unchanged" };
-  mkdirSync2(dirname3(abs), { recursive: true });
-  writeFileSync5(abs, next);
+  mkdirSync3(dirname3(abs), { recursive: true });
+  writeFileSync6(abs, next);
   return { path: target.path, result: existing === null ? "created" : "updated" };
 }
 
 // src/version.ts
-import { readFileSync as readFileSync7 } from "node:fs";
+import { readFileSync as readFileSync8 } from "node:fs";
 function cliVersion() {
   try {
-    const parsed = JSON.parse(readFileSync7(new URL("../package.json", import.meta.url), "utf8"));
+    const parsed = JSON.parse(readFileSync8(new URL("../package.json", import.meta.url), "utf8"));
     return typeof parsed.version === "string" ? parsed.version : "unknown";
   } catch {
     return "unknown";
@@ -3108,8 +3951,8 @@ function manifestReader() {
 }
 function sameOutput(a, b) {
   const selectionKey = (s) => JSON.stringify([s.foundation, s.components === null ? null : [...new Set(s.components.map(slugify))].sort()]);
-  const dtcgKey = (d) => JSON.stringify(sortKeys(d ?? {}));
-  return selectionKey(a.selection) === selectionKey(b.selection) && dtcgKey(a.dtcg) === dtcgKey(b.dtcg);
+  const key = (v) => JSON.stringify(sortKeys(v ?? {}));
+  return selectionKey(a.selection) === selectionKey(b.selection) && key(a.dtcg) === key(b.dtcg) && key(a.outputs ?? []) === key(b.outputs ?? []) && (a.componentSpecsDir ?? DEFAULT_COMPONENT_SPECS_DIR) === (b.componentSpecsDir ?? DEFAULT_COMPONENT_SPECS_DIR);
 }
 function sortKeys(value) {
   if (Array.isArray(value)) return value.map(sortKeys);
@@ -3118,6 +3961,35 @@ function sortKeys(value) {
   }
   return value;
 }
+function platformsFromFlags(flags, io2) {
+  if (flags.platform === void 0 || flags.platform.length === 0) return void 0;
+  const out = [];
+  for (const value of flags.platform) {
+    if (!isPlatform(value)) {
+      io2.err(`--platform takes ${PLATFORMS.join(", ")}, not "${value}".`);
+      return null;
+    }
+    if (!out.includes(value)) out.push(value);
+  }
+  return out;
+}
+function resolvePlatforms(cwd, fromFlags, config) {
+  if (fromFlags) return { platforms: fromFlags, source: "flag" };
+  if (config?.platforms && config.platforms.length > 0) return { platforms: config.platforms, source: "config" };
+  const detected = detectRepo(cwd).platforms;
+  return { platforms: detected, source: detected.length > 0 ? "detected" : "none" };
+}
+function outputsForRun(fromFlags, config, platforms) {
+  if (fromFlags) return withDefaults(config?.outputs ?? [], fromFlags);
+  return config?.outputs ?? defaultOutputs(platforms);
+}
+var NO_PLATFORM_NOTE = `No target platform detected, so no token files were written for your code. Pass --platform ${PLATFORMS.join("|")}, or add outputs to speclayer.json.`;
+function platformsMissingFormat(platforms) {
+  return platforms.filter((p) => !FORMATS.some((f) => f.platform === p));
+}
+function missingFormatNote(platforms) {
+  return `No token files exist yet for ${platforms.join(", ")}: no output format is available for that platform. Web has css.`;
+}
 var errorText = (err) => err instanceof Error ? err.message : String(err);
 function runInit(cwd, flags, io2) {
   if (!flags.id) {
@@ -3131,9 +4003,25 @@ function runInit(cwd, flags, io2) {
     io2.err(errorText(err));
     return 1;
   }
+  const fromFlags = platformsFromFlags(flags, io2);
+  if (fromFlags === null) return 1;
+  const { platforms, source } = resolvePlatforms(cwd, fromFlags, null);
+  const outputs = defaultOutputs(platforms);
   const outDir = flags.out ?? DEFAULT_OUT_DIR;
-  writeConfig(cwd, { libraryId: flags.id, outDir, ...include ? { include } : {} });
-  io2.out(`Wrote speclayer.json (library ${flags.id}, output ${outDir}).`);
+  writeConfig(cwd, {
+    libraryId: flags.id,
+    outDir,
+    componentSpecsDir: DEFAULT_COMPONENT_SPECS_DIR,
+    ...include ? { include } : {},
+    ...platforms.length > 0 ? { platforms } : {},
+    ...outputs.length > 0 ? { outputs } : {}
+  });
+  io2.out(`Wrote speclayer.json (library ${flags.id}, output ${outDir}${platforms.length > 0 ? `, platforms ${platforms.join(", ")}` : ""}).`);
+  for (const o of outputs) io2.out(`Token files for ${o.platform}: ${o.path}/ (${o.format}, ${o.case} names), written by the next pull.`);
+  if (source === "flag" || source === "detected") {
+    const missing = platformsMissingFormat(platforms);
+    if (missing.length > 0) io2.out(missingFormatNote(missing));
+  }
   io2.out(`The pull key is not stored here. Run spec-layer setup to store it in ${CREDENTIALS_NAME}, or set SPEC_LAYER_KEY.`);
   return 0;
 }
@@ -3157,7 +4045,7 @@ function resolved(cwd, flags, env, io2, manifestAt) {
 }
 function resolvedOutDir(cwd, flags, io2) {
   try {
-    return join7(cwd, flags.out ?? readConfig(cwd)?.outDir ?? DEFAULT_OUT_DIR);
+    return join8(cwd, flags.out ?? readConfig(cwd)?.outDir ?? DEFAULT_OUT_DIR);
   } catch (err) {
     io2.err(errorText(err));
     return null;
@@ -3193,16 +4081,24 @@ async function runSetup(cwd, flags, env, io2, fetcher) {
   } catch {
     existing = null;
   }
+  const fromFlags = platformsFromFlags(flags, io2);
+  if (fromFlags === null) return 1;
   const outDir = flags.out ?? existing?.outDir ?? DEFAULT_OUT_DIR;
+  const componentSpecsDir = existing?.componentSpecsDir ?? DEFAULT_COMPONENT_SPECS_DIR;
   const keptInclude = include ?? existing?.include ?? null;
   const keptDtcg = existing?.dtcg ?? null;
+  const { platforms } = resolvePlatforms(cwd, fromFlags, existing);
+  const outputs = withDefaults(existing?.outputs ?? [], platforms);
   writeConfig(cwd, {
     libraryId: flags.id,
     outDir,
+    componentSpecsDir,
     ...keptInclude ? { include: keptInclude } : {},
-    ...keptDtcg ? { dtcg: keptDtcg } : {}
+    ...keptDtcg ? { dtcg: keptDtcg } : {},
+    ...platforms.length > 0 ? { platforms } : {},
+    ...existing?.outputs !== void 0 || outputs.length > 0 ? { outputs } : {}
   });
-  io2.out(`Wrote speclayer.json (library ${flags.id}, output ${outDir}).`);
+  io2.out(`Wrote speclayer.json (library ${flags.id}, output ${outDir}${platforms.length > 0 ? `, platforms ${platforms.join(", ")}` : ""}).`);
   const ignored = ensureIgnored(cwd, CREDENTIALS_NAME);
   switch (ignored.kind) {
     case "refused":
@@ -3249,6 +4145,12 @@ git rm --cached ${ignored.line}`);
   io2.out("spec-layer skill prints the same guide; spec-layer tools lists every command.");
   return 0;
 }
+function outputFilesOnDisk(cwd, outDir, o) {
+  const mapPath = join8(cwd, outDir, "outputs", `${outputId(o)}.map.json`);
+  if (!existsSync8(mapPath)) return false;
+  const imports = readIndexImports(cwd, o);
+  return imports !== null && imports.every((f) => existsSync8(resolve5(cwd, o.path, f)));
+}
 async function runPull(cwd, flags, env, io2, fetcher) {
   const manifestAt = manifestReader();
   const opts = resolved(cwd, flags, env, io2, manifestAt);
@@ -3260,11 +4162,18 @@ async function runPull(cwd, flags, env, io2, fetcher) {
     io2.err(errorText(err));
     return 1;
   }
-  const manifest = manifestAt(join7(cwd, opts.outDir));
+  const fromFlags = platformsFromFlags(flags, io2);
+  if (fromFlags === null) return 1;
+  const { platforms, source } = resolvePlatforms(cwd, fromFlags, opts);
+  const outputs = outputsForRun(fromFlags, opts, platforms);
+  const manifest = manifestAt(join8(cwd, opts.outDir));
+  const foundationOnDisk = Boolean(manifest?.artifacts.find((a) => a.kind === "foundation")?.path);
+  const willWriteFoundation = selection.foundation && foundationOnDisk;
+  const briefsOnDisk = (manifest?.artifacts ?? []).filter((a) => a.kind === "component" && a.path !== null).every((a) => existsSync8(resolve5(cwd, a.path)));
   const etag = manifest && sameOutput(
-    { selection: manifest.selection ?? DEFAULT_SELECTION, dtcg: manifest.dtcg },
-    { selection, dtcg: opts.dtcg }
-  ) ? manifest.bundleHash : void 0;
+    { selection: manifest.selection ?? DEFAULT_SELECTION, dtcg: manifest.dtcg, outputs: manifest.outputs, componentSpecsDir: manifest.componentSpecsDir },
+    { selection, dtcg: opts.dtcg, outputs, componentSpecsDir: opts.componentSpecsDir }
+  ) && briefsOnDisk && (!willWriteFoundation || outputs.every((o) => outputFilesOnDisk(cwd, opts.outDir, o))) ? manifest.bundleHash : void 0;
   const result = await fetchBundle({
     api: opts.api,
     libraryId: opts.libraryId,
@@ -3281,11 +4190,13 @@ async function runPull(cwd, flags, env, io2, fetcher) {
     return 0;
   }
   let written;
+  let componentSpecs;
+  let outputResults;
   try {
     const bundle = parseBundle(result.raw);
     const selected = selectComponents(bundle, selection);
-    written = writeBundleFiles({
-      outDir: join7(cwd, opts.outDir),
+    const writeResult = writeBundleFiles({
+      outDir: join8(cwd, opts.outDir),
       cwd,
       raw: result.raw,
       bundle,
@@ -3293,8 +4204,14 @@ async function runPull(cwd, flags, env, io2, fetcher) {
       libraryId: opts.libraryId,
       publishedAt: result.publishedAt,
       bundleHash: result.bundleHash,
-      dtcg: opts.dtcg
+      dtcg: opts.dtcg,
+      platforms,
+      outputs,
+      componentSpecsDir: opts.componentSpecsDir
     });
+    written = writeResult.written;
+    componentSpecs = writeResult.componentSpecs;
+    outputResults = writeResult.outputs;
     io2.out(
       `Pulled ${bundle.fileName ?? opts.libraryId}: ${describePull(bundle, selection, selected)} (published ${result.publishedAt}).`
     );
@@ -3302,14 +4219,35 @@ async function runPull(cwd, flags, env, io2, fetcher) {
     io2.err(errorText(err));
     return 1;
   }
+  const count = (n) => `${n} file${n === 1 ? "" : "s"}`;
   io2.out(`Wrote ${written.length} files under ${opts.outDir}/.`);
+  if (componentSpecs.files.length > 0) io2.out(`Wrote ${componentSpecs.path}/ (${count(componentSpecs.files.length)}).`);
+  for (const r of outputResults) {
+    const o = outputs.find((x) => x.path === r.path);
+    if (o) io2.out(`Wrote ${r.path}/ (${count(r.files.length)}, ${o.platform}/${o.format}, ${o.case} names).`);
+  }
+  const staleDirNote = (previous, current) => {
+    if (previous !== current && existsSync8(resolve5(cwd, previous))) {
+      io2.out(`The previous pull wrote ${previous}/; this one wrote ${current}/. Delete ${previous}/ if nothing else uses it.`);
+    }
+  };
+  if (manifest) staleDirNote(manifest.componentSpecsDir ?? DEFAULT_COMPONENT_SPECS_DIR, opts.componentSpecsDir);
+  for (const prev of manifest?.outputs ?? []) {
+    const current = outputs.find((o) => outputId(o) === outputId(prev));
+    if (current) staleDirNote(prev.path, current.path);
+  }
+  if (outputResults.length === 0 && selection.foundation && source === "none" && opts.outputs === void 0) io2.out(NO_PLATFORM_NOTE);
+  if (source === "flag" || source === "config") {
+    const missing = platformsMissingFormat(platforms);
+    if (missing.length > 0) io2.out(missingFormatNote(missing));
+  }
   return 0;
 }
 async function runStatus(cwd, flags, env, io2, fetcher) {
   const manifestAt = manifestReader();
   const opts = resolved(cwd, flags, env, io2, manifestAt);
   if (!opts) return 1;
-  const manifest = manifestAt(join7(cwd, opts.outDir));
+  const manifest = manifestAt(join8(cwd, opts.outDir));
   if (!manifest) {
     io2.err(NO_LOCAL_PULL);
     return 2;
@@ -3341,11 +4279,15 @@ function runList(cwd, flags, io2) {
     return 1;
   }
   io2.out(`Library ${manifest.libraryId}, published ${manifest.publishedAt}.`);
-  const rows = manifest.artifacts.map((a) => [a.kind, a.name, a.aiPath ?? "not written", a.contentHash]);
+  const rows = manifest.artifacts.map((a) => [a.kind, a.name, a.path ?? "not written", a.contentHash]);
   const widths = [0, 1, 2].map((i) => Math.max(...rows.map((r) => r[i].length)));
   for (const row of rows) {
     io2.out(row.map((cell, i) => i < 3 ? cell.padEnd(widths[i]) : cell).join("  "));
   }
+  for (const o of manifest.outputs ?? []) {
+    const written = existsSync8(join8(outDir, "outputs", `${o.platform}-${o.format}.map.json`));
+    io2.out(["output".padEnd(widths[0]), `${o.platform}/${o.format}`.padEnd(widths[1]), written ? o.path : "not written"].join("  "));
+  }
   return 0;
 }
 var SHOW_USAGE = 'spec-layer show takes "foundation" or "component NAME".';
@@ -3410,20 +4352,10 @@ function collectSkillInput(cwd, flags, io2) {
   }
   const outDir = flags.out ?? config?.outDir ?? DEFAULT_OUT_DIR;
   const profile = detectRepo(cwd);
-  let platforms;
-  let platformSource;
-  if (flags.platform !== void 0) {
-    if (!isPlatform(flags.platform)) {
-      io2.err(`--platform takes ${PLATFORMS.join(", ")}, not "${flags.platform}".`);
-      return null;
-    }
-    platforms = [flags.platform];
-    platformSource = "flag";
-  } else {
-    platforms = profile.platforms;
-    platformSource = platforms.length > 0 ? "detected" : "none";
-  }
-  const pull = summarizePull(cwd, outDir, readManifest(join7(cwd, outDir)));
+  const fromFlags = platformsFromFlags(flags, io2);
+  if (fromFlags === null) return null;
+  const { platforms, source: platformSource } = resolvePlatforms(cwd, fromFlags, config);
+  const pull = summarizePull(cwd, outDir, readManifest(join8(cwd, outDir)));
   return { profile, platforms, platformSource, outDir, config, pull, version: cliVersion() };
 }
 function skillHosts(flags, input, io2) {
@@ -3484,17 +4416,18 @@ function runSkill(cwd, flags, io2) {
 var USAGE = `spec-layer <command>
 
 Commands:
-  setup   --id lib_... --key sl_... [--out DIR] [selection]
+  setup   --id lib_... --key sl_... [--out DIR] [selection] [--platform P]...
                                                  store the key, then pull
-  init    --id lib_... [--out DIR] [selection]   write speclayer.json
-  pull    [--id lib_...] [--key sl_...] [selection]
+  init    --id lib_... [--out DIR] [selection] [--platform P]...
+                                                 write speclayer.json
+  pull    [--id lib_...] [--key sl_...] [selection] [--platform P]...
                                                  fetch the library into DIR (default .speclayer); the foundation lands as DTCG under DIR/tokens/
   status  [--id lib_...] [--key sl_...]          check freshness; exits 2 when behind
   list                                           list every artifact in the last pull
   show    foundation | component NAME [--canonical]
                                                  print one artifact (foundation: the DTCG document; component: its AI YAML; --canonical for JSON)
   tools   [--json]                               list every command with what it reaches and writes
-  skill   [--install] [--agent HOST]... [--platform P] [--json]
+  skill   [--install] [--agent HOST]... [--platform P]... [--json]
                                                  print a guide for a coding agent, adapted to this repo and the last pull;
                                                  --install writes it for claude, cursor, copilot, windsurf, gemini, or agents-md
 
@@ -3504,6 +4437,7 @@ Selection (setup, pull and init; flags replace the include block in speclayer.js
 
 Options:
   --api URL   override the API origin (default https://api.spec-layer.com)
+  --platform web|ios|android|flutter   the target this repo builds for (repeatable); applies to setup, init, pull, and skill; setup and init store it, pull uses it for the run
 The pull key comes from --key, SPEC_LAYER_KEY, or speclayer.local.json written by setup.`;
 var io = {
   out: (l) => console.log(l),
@@ -3529,7 +4463,7 @@ async function main() {
         json: { type: "boolean" },
         install: { type: "boolean" },
         agent: { type: "string", multiple: true },
-        platform: { type: "string" }
+        platform: { type: "string", multiple: true }
       }
     }));
   } catch {