@zeroxsolutions/zaku 0.0.2 → 0.0.4

package/dist/zaku.mjs

@@ -12066,7 +12066,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash: createHash2 } = __require("crypto");
+    var { randomBytes, createHash: createHash3 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -12747,7 +12747,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash2("sha1").update(key + GUID).digest("base64");
+        const digest = createHash3("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -13116,7 +13116,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter2 = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash2 } = __require("crypto");
+    var { createHash: createHash3 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -13423,7 +13423,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash2("sha1").update(key + GUID).digest("base64");
+        const digest = createHash3("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -17351,49 +17351,49 @@ var require_fast_uri = __commonJS({
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base, relative, options, skipNormalization) {
+    function resolveComponent(base, relative3, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base = parse4(serialize(base, options), options);
-        relative = parse4(serialize(relative, options), options);
+        relative3 = parse4(serialize(relative3, options), options);
       }
       options = options || {};
-      if (!options.tolerant && relative.scheme) {
-        target.scheme = relative.scheme;
-        target.userinfo = relative.userinfo;
-        target.host = relative.host;
-        target.port = relative.port;
-        target.path = removeDotSegments(relative.path || "");
-        target.query = relative.query;
+      if (!options.tolerant && relative3.scheme) {
+        target.scheme = relative3.scheme;
+        target.userinfo = relative3.userinfo;
+        target.host = relative3.host;
+        target.port = relative3.port;
+        target.path = removeDotSegments(relative3.path || "");
+        target.query = relative3.query;
       } else {
-        if (relative.userinfo !== void 0 || relative.host !== void 0 || relative.port !== void 0) {
-          target.userinfo = relative.userinfo;
-          target.host = relative.host;
-          target.port = relative.port;
-          target.path = removeDotSegments(relative.path || "");
-          target.query = relative.query;
+        if (relative3.userinfo !== void 0 || relative3.host !== void 0 || relative3.port !== void 0) {
+          target.userinfo = relative3.userinfo;
+          target.host = relative3.host;
+          target.port = relative3.port;
+          target.path = removeDotSegments(relative3.path || "");
+          target.query = relative3.query;
         } else {
-          if (!relative.path) {
+          if (!relative3.path) {
             target.path = base.path;
-            if (relative.query !== void 0) {
-              target.query = relative.query;
+            if (relative3.query !== void 0) {
+              target.query = relative3.query;
             } else {
               target.query = base.query;
             }
           } else {
-            if (relative.path[0] === "/") {
-              target.path = removeDotSegments(relative.path);
+            if (relative3.path[0] === "/") {
+              target.path = removeDotSegments(relative3.path);
             } else {
               if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-                target.path = "/" + relative.path;
+                target.path = "/" + relative3.path;
               } else if (!base.path) {
-                target.path = relative.path;
+                target.path = relative3.path;
               } else {
-                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
+                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative3.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative.query;
+            target.query = relative3.query;
           }
           target.userinfo = base.userinfo;
           target.host = base.host;
@@ -17401,7 +17401,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base.scheme;
       }
-      target.fragment = relative.fragment;
+      target.fragment = relative3.fragment;
       return target;
     }
     function equal(uriA, uriB, options) {
@@ -20678,10 +20678,10 @@ var require_dist2 = __commonJS({
 
 // apps/zaku-cli/src/cli.ts
 var import_reflect_metadata3 = __toESM(require_Reflect(), 1);
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname4, join as join10, resolve as resolve2, sep } from "node:path";
+import { dirname as dirname4, join as join12, resolve as resolve2, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // node_modules/.pnpm/commander@15.0.0/node_modules/commander/lib/error.js
@@ -21859,7 +21859,7 @@ var Command = class _Command extends EventEmitter {
     this._outputConfiguration = {
       writeOut: (str) => process2.stdout.write(str),
       writeErr: (str) => process2.stderr.write(str),
-      outputError: (str, write) => write(str),
+      outputError: (str, write2) => write2(str),
       getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : void 0,
       getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : void 0,
       getOutHasColors: () => useColor() ?? (process2.stdout.isTTY && process2.stdout.hasColors?.()),
@@ -23844,11 +23844,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
       hasColors = this._outputConfiguration.getOutHasColors();
       helpWidth = this._outputConfiguration.getOutHelpWidth();
     }
-    const write = (str) => {
+    const write2 = (str) => {
       if (!hasColors) str = this._outputConfiguration.stripColor(str);
       return baseWrite(str);
     };
-    return { error: error62, write, hasColors, helpWidth };
+    return { error: error62, write: write2, hasColors, helpWidth };
   }
   /**
    * Output help information for this command.
@@ -24178,11 +24178,15 @@ var WriteRecipe = class extends DomainCommand {
 // packages/zaku/dist/lib/commands/save-library.js
 var SaveLibrary = class extends DomainCommand {
   root;
+  key;
   part;
   constructor(input2) {
     super();
     this.root = input2.root;
-    this.part = input2.part;
+    if (input2.key !== void 0)
+      this.key = input2.key;
+    if (input2.part !== void 0)
+      this.part = input2.part;
   }
 };
 
@@ -24325,8 +24329,8 @@ function parseCssColour(value) {
     return null;
   return name === "oklch" ? oklchToRgba(l, x, y, round(alpha)) : oklabToRgba(l, x, y, round(alpha));
 }
-function rgbaToOklab(colour2) {
-  const [r, g, b] = [decode(colour2.r), decode(colour2.g), decode(colour2.b)];
+function rgbaToOklab(colour3) {
+  const [r, g, b] = [decode(colour3.r), decode(colour3.g), decode(colour3.b)];
   const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
   const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
   const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
@@ -24341,12 +24345,12 @@ function deltaEOk(a, b) {
   const [l2, a2, b2] = rgbaToOklab(b);
   return Math.round(Math.hypot(l1 - l2, a1 - a2, b1 - b2, a.a - b.a) * 100 * 1e3) / 1e3;
 }
-function toHex(colour2) {
-  const channels = [colour2.r, colour2.g, colour2.b].map((value) => Math.round(clamp(value) * 255).toString(16).padStart(2, "0"));
+function toHex(colour3) {
+  const channels = [colour3.r, colour3.g, colour3.b].map((value) => Math.round(clamp(value) * 255).toString(16).padStart(2, "0"));
   return `#${channels.join("")}`;
 }
-function luminance(colour2) {
-  return 0.2126 * decode(colour2.r) + 0.7152 * decode(colour2.g) + 0.0722 * decode(colour2.b);
+function luminance(colour3) {
+  return 0.2126 * decode(colour3.r) + 0.7152 * decode(colour3.g) + 0.0722 * decode(colour3.b);
 }
 function contrastRatio(fg, bg) {
   const over = (front, back) => front * fg.a + back * (1 - fg.a);
@@ -44393,6 +44397,18 @@ var FigmaTokenMissing = class extends Error {
   }
 };
 
+// packages/zaku/dist/lib/domain/errors/library-key-missing.js
+var LibraryKeyMissing = class extends Error {
+  keys;
+  given;
+  constructor(keys, given) {
+    super(given === void 0 ? `zaku.yaml lists several libraries and kits; name one with --key: ${keys.join(", ")}` : `${given} is not a library or kit zaku.yaml lists; name one with --key: ${keys.join(", ")}`);
+    this.keys = keys;
+    this.given = given;
+    this.name = "LibraryKeyMissing";
+  }
+};
+
 // packages/zaku/dist/lib/domain/errors/playwright-missing.js
 var PlaywrightMissing = class extends Error {
   constructor() {
@@ -44518,18 +44534,18 @@ function radiiOf(raw) {
   return fitRadii(corners, raw.width, raw.height);
 }
 function partOf(raw, at) {
-  const colour2 = (field, value) => {
+  const colour3 = (field, value) => {
     const parsed = parseCssColour(value);
     if (!parsed)
       throw new Error(`${at}, part ${raw.part}: ${field} is ${value}, which zaku does not read`);
     return parsed;
   };
-  const background = colour2("background", raw.background);
+  const background = colour3("background", raw.background);
   const gap = Number.parseFloat(raw.gap);
   return {
     background: background.a === 0 ? null : background,
-    color: colour2("color", raw.color),
-    borderColor: raw.borderWidths.some((width) => width > 0) ? colour2("borderColor", raw.borderColor) : null,
+    color: colour3("color", raw.color),
+    borderColor: raw.borderWidths.some((width) => width > 0) ? colour3("borderColor", raw.borderColor) : null,
     borderWidths: raw.borderWidths,
     width: raw.width,
     height: raw.height,
@@ -44611,13 +44627,106 @@ WriteRecipeHandler = __decorate2([
 
 // packages/zaku/dist/lib/handlers/save-library.js
 var import_tsyringe3 = __toESM(require_cjs(), 1);
-import { writeFile as writeFile2 } from "node:fs/promises";
+import { relative as relative2 } from "node:path";
 
 // packages/zaku/dist/lib/domain/copy-defaults.js
 var DEFAULT_COPY = { locales: ["en"], currencies: [] };
 
+// packages/zaku/dist/lib/domain/design-graph.js
+var DESKTOP_FAMILIES = /* @__PURE__ */ new Set(["macos", "windows", "gnome", "kde"]);
+function defaultBranch(family) {
+  if (family === "web")
+    return "ui";
+  return DESKTOP_FAMILIES.has(family) ? void 0 : "native";
+}
+function defaultPlatform(family) {
+  if (family === "web")
+    return "web-app";
+  return DESKTOP_FAMILIES.has(family) ? "desktop" : "mobile";
+}
+var branchOf = (target) => target.branch ?? defaultBranch(target.family);
+var platformOf = (target) => target.platform ?? defaultPlatform(target.family);
+var unique = (values) => [...new Set(values)];
+function legacyFiles(config2) {
+  const branches = unique(config2.targets.flatMap((target) => branchOf(target) ?? []));
+  const platforms = unique(config2.targets.map(platformOf));
+  const { library, product } = config2.figma;
+  return {
+    libraries: library === void 0 ? [] : [{ key: library, layer: "foundations", branches: branches.length > 0 ? branches : ["ui"], extends: [] }],
+    products: product === void 0 ? [] : platforms.map((platform) => ({ key: product, platform }))
+  };
+}
+function designGraph(config2) {
+  const { figma } = config2;
+  const legacy = figma.library !== void 0 || figma.product !== void 0;
+  const { libraries, products } = legacy ? legacyFiles(config2) : { libraries: figma.libraries ?? [], products: figma.products ?? [] };
+  const kits = figma.kits ?? [];
+  const prototypes = figma.prototypes ?? [];
+  const byKey = new Map(libraries.map((library) => [library.key, library]));
+  const closure = (key) => {
+    const out = [];
+    const visit2 = (next) => {
+      if (out.includes(next))
+        return;
+      out.push(next);
+      for (const base of byKey.get(next)?.extends ?? [])
+        visit2(base);
+    };
+    visit2(key);
+    return out;
+  };
+  return {
+    libraries,
+    kits,
+    products,
+    prototypes,
+    legacy,
+    branchOf,
+    platformOf,
+    librariesFor: (target) => {
+      if (legacy)
+        return libraries;
+      const branch = branchOf(target);
+      return libraries.filter((library) => branch !== void 0 && library.branches.includes(branch));
+    },
+    kitsFor: (target) => kits.filter((kit) => kit.family === target.family),
+    closure,
+    multiBranch: (key) => (byKey.get(key)?.branches.length ?? 0) > 1,
+    productOf: (prototypeKey) => {
+      const prototype2 = prototypes.find((candidate) => candidate.key === prototypeKey);
+      return prototype2?.product ?? (products.length === 1 ? products[0]?.key : void 0);
+    }
+  };
+}
+function snapshotsFor(input2, target) {
+  const graph = designGraph(input2.config);
+  const branch = target ? graph.branchOf(target) : void 0;
+  const missing = [];
+  const libraries = (target ? graph.librariesFor(target) : graph.libraries).flatMap((library) => {
+    const snapshot = input2.libraries[library.key];
+    if (!snapshot) {
+      missing.push(library.key);
+      return [];
+    }
+    if (!target || !graph.multiBranch(library.key))
+      return [snapshot];
+    const components = snapshot.components.filter((component2) => component2.branch === void 0 || component2.branch === branch);
+    return [{ ...snapshot, components }];
+  });
+  const kits = (target ? graph.kitsFor(target) : graph.kits).flatMap((kit) => {
+    const snapshot = input2.kits[kit.key];
+    if (!snapshot)
+      missing.push(kit.key);
+    return snapshot ? [snapshot] : [];
+  });
+  return { libraries, kits, missing };
+}
+
 // packages/zaku/dist/lib/schema/zaku-config.js
 var PLATFORM_FAMILIES = ["web", "ios", "android", "macos", "windows", "gnome", "kde"];
+var LAYERS = ["foundations", "components"];
+var BRANCHES = ["ui", "native"];
+var PLATFORMS = ["web-app", "mobile", "desktop"];
 var DEFAULT_INTERACTIVE = [
   "Button",
   "Button Group",
@@ -44644,7 +44753,11 @@ var targetSchema = external_exports.object({
   family: external_exports.enum(PLATFORM_FAMILIES),
   name: external_exports.string().regex(/^\S(.*\S)?$/, "a name has no leading or trailing space").refine((name) => !name.includes("/"), "a name has no slash, which separates the parts of a frame name"),
   /** The frame size every frame of this target is drawn at; the frame check compares it. */
-  size: external_exports.object({ width: external_exports.number().positive(), height: external_exports.number().positive() }).strict().optional()
+  size: external_exports.object({ width: external_exports.number().positive(), height: external_exports.number().positive() }).strict().optional(),
+  /** The renderer whose libraries its frames draw from; `defaultBranch` in the design graph gives it when left out. */
+  branch: external_exports.enum(BRANCHES).optional(),
+  /** What its frames serve; `defaultPlatform` in the design graph gives it when left out. */
+  platform: external_exports.enum(PLATFORMS).optional()
 }).strict();
 var DEFAULT_SYSTEM_BARS = {
   web: [],
@@ -44664,7 +44777,33 @@ var budgetSchema = external_exports.object({
   mcpPerRun: external_exports.number().int().positive().default(30),
   reserve: external_exports.number().min(0).max(1).default(0.2)
 }).strict();
-var files = external_exports.object({ library: external_exports.string().min(1).optional(), product: external_exports.string().min(1).optional() }).strict();
+var fileKey = external_exports.string().min(1);
+var kitSchema = external_exports.object({ key: fileKey, family: external_exports.enum(PLATFORM_FAMILIES) }).strict();
+var librarySchema = external_exports.object({
+  key: fileKey,
+  layer: external_exports.enum(LAYERS),
+  branches: external_exports.array(external_exports.enum(BRANCHES)).min(1),
+  /** The libraries and kits this one is built on, by key. */
+  extends: external_exports.array(fileKey).default([])
+}).strict();
+var productSchema = external_exports.object({ key: fileKey, platform: external_exports.enum(PLATFORMS) }).strict();
+var prototypeSchema = external_exports.object({
+  key: fileKey,
+  platform: external_exports.enum(PLATFORMS),
+  /** The product file its frames are copied from; required when there are several. */
+  product: fileKey.optional()
+}).strict();
+var files = external_exports.object({
+  library: fileKey.optional(),
+  product: fileKey.optional(),
+  kits: external_exports.array(kitSchema).optional(),
+  libraries: external_exports.array(librarySchema).optional(),
+  products: external_exports.array(productSchema).optional(),
+  prototypes: external_exports.array(prototypeSchema).optional()
+}).strict();
+function byRole(figma) {
+  return [figma.kits, figma.libraries, figma.products, figma.prototypes].some((list) => list !== void 0);
+}
 var shadcnSystem = external_exports.object({ preset: external_exports.string().min(1) }).strict();
 var tokenFiles = external_exports.array(external_exports.string().min(1)).min(1);
 var resolverInputs = external_exports.record(external_exports.string(), external_exports.string());
@@ -44716,7 +44855,7 @@ var copySchema = external_exports.object({
   locales: external_exports.array(external_exports.string().refine(writtenInAScript, "a BCP 47 language tag, such as en or vi")).min(1).default(["en"]),
   currencies: external_exports.array(external_exports.string().refine((code) => Intl.supportedValuesOf("currency").includes(code), "an ISO 4217 code, such as VND or USD")).default([])
 }).strict();
-var zakuConfigSchema = external_exports.object({
+var configShape = external_exports.object({
   product: external_exports.string().min(1),
   designSystem: designSystemSchema,
   figma: files.default({}),
@@ -44728,7 +44867,8 @@ var zakuConfigSchema = external_exports.object({
   budget: budgetSchema.default({ mcpPerDay: 200, mcpPerRun: 30, reserve: 0.2 }),
   recipe: recipeSchema.optional(),
   copy: copySchema.default(DEFAULT_COPY)
-}).strict().superRefine((config2, ctx) => {
+}).strict();
+var zakuConfigSchema = configShape.superRefine((config2, ctx) => {
   for (const key of ["id", "name"]) {
     const seen = /* @__PURE__ */ new Set();
     config2.targets.forEach((target, index) => {
@@ -44742,7 +44882,112 @@ var zakuConfigSchema = external_exports.object({
       seen.add(target[key]);
     });
   }
+  if (byRole(config2.figma))
+    refineFilesByRole(config2, ctx);
 });
+function refineFilesByRole(config2, ctx) {
+  const { figma } = config2;
+  if (figma.library !== void 0 || figma.product !== void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["figma"],
+      message: "figma.library and figma.product describe one library and one product; list files by role instead"
+    });
+  }
+  const kits = figma.kits ?? [];
+  const libraries = figma.libraries ?? [];
+  const products = figma.products ?? [];
+  const seen = /* @__PURE__ */ new Set();
+  const lists = [
+    ["kits", kits],
+    ["libraries", libraries],
+    ["products", products],
+    ["prototypes", figma.prototypes ?? []]
+  ];
+  for (const [list, entries] of lists) {
+    entries.forEach((entry, index) => {
+      if (seen.has(entry.key))
+        ctx.addIssue({
+          code: "custom",
+          path: ["figma", list, index, "key"],
+          message: `a second file with key ${entry.key}`
+        });
+      seen.add(entry.key);
+    });
+  }
+  const byKey = new Map(libraries.map((library) => [library.key, library]));
+  const kitKeys = new Set(kits.map((kit) => kit.key));
+  libraries.forEach((library, index) => {
+    const path2 = ["figma", "libraries", index, "extends"];
+    for (const key of library.extends) {
+      const base = byKey.get(key);
+      if (!base && !kitKeys.has(key)) {
+        ctx.addIssue({
+          code: "custom",
+          path: path2,
+          message: `${library.key} extends ${key}, which is no library or kit listed`
+        });
+      } else if (base?.layer === "components" && library.layer === "foundations") {
+        ctx.addIssue({ code: "custom", path: path2, message: `foundations ${library.key} extends components ${key}` });
+      } else if (base && !base.branches.some((branch) => library.branches.includes(branch))) {
+        ctx.addIssue({
+          code: "custom",
+          path: path2,
+          message: `${library.key} extends ${key}, which holds none of its branches`
+        });
+      }
+    }
+  });
+  const cycle = findCycle(libraries);
+  if (cycle)
+    ctx.addIssue({ code: "custom", path: ["figma", "libraries"], message: `extends comes back: ${cycle}` });
+  (figma.prototypes ?? []).forEach((prototype2, index) => {
+    const path2 = ["figma", "prototypes", index];
+    if (prototype2.product === void 0) {
+      if (products.length > 1)
+        ctx.addIssue({ code: "custom", path: [...path2, "product"], message: "name the product its frames come from" });
+      return;
+    }
+    const product = products.find((candidate) => candidate.key === prototype2.product);
+    if (!product) {
+      ctx.addIssue({ code: "custom", path: [...path2, "product"], message: `no product with key ${prototype2.product}` });
+    } else if (product.platform !== prototype2.platform) {
+      ctx.addIssue({
+        code: "custom",
+        path: [...path2, "platform"],
+        message: `${prototype2.platform}, and its product serves ${product.platform}`
+      });
+    }
+  });
+  config2.targets.forEach((target, index) => {
+    const branch = target.branch ?? defaultBranch(target.family);
+    const path2 = ["targets", index, "branch"];
+    if (branch === void 0) {
+      ctx.addIssue({ code: "custom", path: path2, message: `a ${target.family} target names its branch, ui or native` });
+    } else if (libraries.length > 0 && !libraries.some((library) => library.branches.includes(branch))) {
+      ctx.addIssue({ code: "custom", path: path2, message: `no library holds the ${branch} branch` });
+    }
+  });
+}
+function findCycle(libraries) {
+  const byKey = new Map(libraries.map((library) => [library.key, library]));
+  const visit2 = (key, path2) => {
+    if (path2.includes(key))
+      return [...path2.slice(path2.indexOf(key)), key].join(" -> ");
+    for (const next of byKey.get(key)?.extends ?? []) {
+      const found = visit2(next, [...path2, key]);
+      if (found)
+        return found;
+    }
+    return void 0;
+  };
+  for (const library of libraries) {
+    const found = visit2(library.key, []);
+    if (found)
+      return found;
+  }
+  return void 0;
+}
 
 // packages/zaku/dist/lib/repositories/design-file.js
 var import_yaml = __toESM(require_dist(), 1);
@@ -44783,6 +45028,12 @@ async function writeDesignFile(path2, value) {
 
 // packages/zaku/dist/lib/repositories/design-paths.js
 import { join as join2 } from "node:path";
+function librarySnapshotDir(paths, key) {
+  if (key === null)
+    return paths;
+  const library = join2(paths.library, key);
+  return { root: paths.root, library, libraryIndex: join2(library, "index.json"), legacyLibrary: null };
+}
 function designPaths(root) {
   return {
     root,
@@ -44790,12 +45041,18 @@ function designPaths(root) {
     maps: join2(root, "map"),
     outline: join2(root, "outline"),
     unmapped: join2(root, "outline", "unmapped.yaml"),
-    library: join2(root, "library.json"),
+    library: join2(root, "library"),
+    libraryIndex: join2(root, "library", "index.json"),
+    legacyLibrary: join2(root, "library.json"),
     tokens: join2(root, "tokens.json"),
     recipe: join2(root, "recipe.json")
   };
 }
 
+// packages/zaku/dist/lib/repositories/library-snapshot.js
+import { mkdir, readdir, readFile as readFile2, rename as rename2, rm, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join3, relative } from "node:path";
+
 // packages/zaku/dist/lib/domain/library.js
 var rgbaSchema = external_exports.object({ r: external_exports.number(), g: external_exports.number(), b: external_exports.number(), a: external_exports.number() }).strict();
 var libraryItemSchema = external_exports.object({
@@ -44820,8 +45077,13 @@ var libraryItemSchema = external_exports.object({
   fontFamily: external_exports.string().nullable(),
   textStyleKey: external_exports.string().nullable(),
   componentKey: external_exports.string().nullable(),
-  bindings: external_exports.record(external_exports.string(), external_exports.string().nullable())
+  bindings: external_exports.record(external_exports.string(), external_exports.string().nullable()),
+  /** Every variable the layer's own properties are bound to, by id without its `VariableID:` prefix. */
+  variableIds: external_exports.array(external_exports.string()).optional(),
+  effectStyleKey: external_exports.string().optional()
 }).strict();
+var variableKeySchema = external_exports.object({ key: external_exports.string(), local: external_exports.boolean() }).strict();
+var effectStyleSchema = external_exports.object({ key: external_exports.string(), name: external_exports.string() }).strict();
 var libraryVariantSchema = external_exports.object({
   key: external_exports.string(),
   name: external_exports.string(),
@@ -44832,6 +45094,8 @@ var libraryComponentSchema = external_exports.object({
   name: external_exports.string(),
   key: external_exports.string(),
   page: external_exports.string(),
+  /** The branch of the view that holds it, in a file that holds several; none where it serves every branch. */
+  branch: external_exports.string().optional(),
   codePath: external_exports.string().nullable(),
   map: external_exports.object({ props: external_exports.record(external_exports.string(), external_exports.string()), parts: external_exports.record(external_exports.string(), external_exports.string()) }).strict().nullable(),
   variants: external_exports.array(libraryVariantSchema).min(1)
@@ -44851,12 +45115,22 @@ var libraryPartSchema = external_exports.object({
   exportedAt: external_exports.string(),
   components: external_exports.array(libraryComponentSchema),
   textStyles: external_exports.array(textStyleSchema),
-  tokens: external_exports.array(tokenSnapshotSchema)
+  tokens: external_exports.array(tokenSnapshotSchema),
+  /**
+   * What the items' references resolve against, absent from a snapshot saved before they were recorded: each
+   * variable id's key, the file's effect styles, and the keys of the components the file holds unpublished.
+   */
+  variableKeys: external_exports.record(external_exports.string(), variableKeySchema).optional(),
+  effectStyles: external_exports.array(effectStyleSchema).optional(),
+  localComponents: external_exports.array(external_exports.string()).optional()
 }).strict();
 var variablePartSchema = external_exports.object({
   exportedAt: external_exports.string(),
   variables: external_exports.record(external_exports.string(), external_exports.string()),
   textStyles: external_exports.array(textStyleSchema),
+  /** Each variable's key, keyed like `variables`. */
+  variableKeys: external_exports.record(external_exports.string(), variableKeySchema).optional(),
+  effectStyles: external_exports.array(effectStyleSchema).optional(),
   tokens: external_exports.array(external_exports.object({
     combo: external_exports.record(external_exports.string(), external_exports.string()),
     values: external_exports.record(external_exports.string(), external_exports.union([external_exports.string(), external_exports.number(), external_exports.boolean()]))
@@ -44867,12 +45141,309 @@ var variablePartSchema = external_exports.object({
     key: external_exports.string(),
     name: external_exports.string(),
     page: external_exports.string(),
+    /** The view that holds it: the frame directly on its page, where it sits in one. */
+    frame: external_exports.string().optional(),
     description: external_exports.string(),
     set: external_exports.boolean()
   }).strict()).optional()
 }).strict();
+var kitSnapshotSchema = external_exports.object({
+  key: external_exports.string(),
+  family: external_exports.string(),
+  components: external_exports.array(external_exports.object({ key: external_exports.string(), name: external_exports.string() }).strict())
+}).strict();
 var librarySnapshotSchema = libraryPartSchema.extend({ source: external_exports.string(), version: external_exports.string() }).strict();
 
+// packages/zaku/dist/lib/domain/library-files.js
+import { isDeepStrictEqual } from "node:util";
+var storedItemSchema = libraryItemSchema.partial().required({ nodeId: true, path: true, type: true, width: true, height: true }).extend({ bindings: libraryItemSchema.shape.bindings.optional(), glyph: rgbaSchema.optional() }).strict();
+var libraryFileSchema = external_exports.object({
+  name: external_exports.string(),
+  key: external_exports.string(),
+  variants: external_exports.array(external_exports.object({
+    key: external_exports.string(),
+    /** The items in the first mode of the index's tokens. */
+    items: external_exports.array(storedItemSchema),
+    /** Only the modes whose stored items differ from the first. */
+    modes: external_exports.array(external_exports.object({ combo: external_exports.record(external_exports.string(), external_exports.string()), items: external_exports.array(storedItemSchema) }).strict()).optional()
+  }).strict())
+}).strict();
+var libraryIndexSchema = librarySnapshotSchema.extend({
+  components: external_exports.array(libraryComponentSchema.omit({ variants: true }).extend({
+    file: external_exports.string(),
+    variants: external_exports.array(libraryVariantSchema.pick({ key: true, name: true, props: true }).strict())
+  }).strict())
+}).strict();
+var NULLABLE = [
+  "fill",
+  "stroke",
+  "textColor",
+  "padding",
+  "gap",
+  "radii",
+  "strokeWeights",
+  "fontSize",
+  "fontFamily",
+  "textStyleKey",
+  "componentKey"
+];
+var RESOLVED = ["fill", "stroke", "textColor", "glyph", "radii"];
+function colour(name, values) {
+  const value = name ? values[name] : void 0;
+  return value !== void 0 && typeof value === "object" ? value : null;
+}
+function expandItem(stored, values) {
+  const bindings = {
+    fill: null,
+    stroke: null,
+    textColor: null,
+    radius: null,
+    ...stored.bindings
+  };
+  const radius = bindings.radius ? values[bindings.radius] : void 0;
+  const glyph = stored.glyph ?? (bindings["glyph"] ? colour(bindings["glyph"], values) : null);
+  return {
+    nodeId: stored.nodeId,
+    path: stored.path,
+    type: stored.type,
+    fill: stored.fill !== void 0 ? stored.fill : colour(bindings.fill, values),
+    stroke: stored.stroke !== void 0 ? stored.stroke : colour(bindings.stroke, values),
+    textColor: stored.textColor !== void 0 ? stored.textColor : colour(bindings.textColor, values),
+    ...glyph ? { glyph } : {},
+    width: stored.width,
+    height: stored.height,
+    padding: stored.padding ?? null,
+    gap: stored.gap ?? null,
+    radii: stored.radii !== void 0 ? stored.radii : typeof radius === "number" ? [radius, radius, radius, radius] : null,
+    strokeWeights: stored.strokeWeights ?? null,
+    fontSize: stored.fontSize ?? null,
+    fontFamily: stored.fontFamily ?? null,
+    textStyleKey: stored.textStyleKey ?? null,
+    componentKey: stored.componentKey ?? null,
+    bindings,
+    ...stored.variableIds ? { variableIds: stored.variableIds } : {},
+    ...stored.effectStyleKey ? { effectStyleKey: stored.effectStyleKey } : {}
+  };
+}
+function compactItem(item, values) {
+  const stored = {
+    nodeId: item.nodeId,
+    path: item.path,
+    type: item.type,
+    width: item.width,
+    height: item.height
+  };
+  for (const field of NULLABLE)
+    if (item[field] !== null)
+      stored[field] = item[field];
+  if (item.glyph)
+    stored["glyph"] = item.glyph;
+  if (item.variableIds)
+    stored["variableIds"] = item.variableIds;
+  if (item.effectStyleKey)
+    stored["effectStyleKey"] = item.effectStyleKey;
+  const bindings = Object.fromEntries(Object.entries(item.bindings).filter(([name, value]) => value !== null || name === "glyph"));
+  if (Object.keys(bindings).length > 0)
+    stored["bindings"] = bindings;
+  for (const field of RESOLVED) {
+    if (!(field in stored))
+      continue;
+    const without = { ...stored };
+    delete without[field];
+    if (isDeepStrictEqual(expandItem(without, values), item))
+      delete stored[field];
+  }
+  return isDeepStrictEqual(expandItem(stored, values), item) ? stored : item;
+}
+function comboKey(combo) {
+  return JSON.stringify(Object.entries(combo).sort(([a], [b]) => a.localeCompare(b)));
+}
+function fileName(name, key, taken) {
+  const slug2 = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "component";
+  const file2 = taken.has(slug2) ? `${slug2}-${key.slice(0, 8)}` : slug2;
+  taken.add(file2);
+  return `components/${file2}.json`;
+}
+function splitLibrary(snapshot) {
+  const valuesOf = new Map(snapshot.tokens.map((token) => [comboKey(token.combo), token.values]));
+  const taken = /* @__PURE__ */ new Set();
+  const files2 = /* @__PURE__ */ new Map();
+  const components = [];
+  for (const { variants, ...component2 } of snapshot.components) {
+    const file2 = fileName(component2.name, component2.key, taken);
+    files2.set(file2, {
+      name: component2.name,
+      key: component2.key,
+      variants: variants.map((variant) => {
+        const stored = variant.modes.map((mode) => ({
+          combo: mode.combo,
+          items: mode.items.map((item) => compactItem(item, valuesOf.get(comboKey(mode.combo)) ?? {}))
+        }));
+        const [first, ...rest] = stored;
+        const modes = rest.filter((mode) => !isDeepStrictEqual(mode.items, first?.items));
+        return { key: variant.key, items: first?.items ?? [], ...modes.length > 0 ? { modes } : {} };
+      })
+    });
+    components.push({
+      ...component2,
+      file: file2,
+      variants: variants.map(({ key, name, props }) => ({ key, name, props }))
+    });
+  }
+  return { index: { ...snapshot, components }, files: files2 };
+}
+function joinLibrary(index, files2) {
+  return {
+    ...index,
+    components: index.components.map(({ file: file2, variants, ...component2 }) => {
+      const stored = files2.get(file2);
+      if (!stored)
+        throw new Error(`library/${file2} is not loaded`);
+      return {
+        ...component2,
+        variants: variants.map((variant, at) => {
+          const items = stored.variants[at];
+          return {
+            ...variant,
+            modes: index.tokens.map((token) => ({
+              combo: token.combo,
+              items: (items?.modes?.find((mode) => comboKey(mode.combo) === comboKey(token.combo))?.items ?? items?.items ?? []).map((item) => expandItem(item, token.values))
+            }))
+          };
+        })
+      };
+    })
+  };
+}
+var ONE_LINE = 100;
+function write(value, pad, key) {
+  const line = JSON.stringify(value);
+  if (value === null || typeof value !== "object" || line.length <= ONE_LINE)
+    return line;
+  const inner = `${pad}  `;
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return "[]";
+    const element = (child) => key === "items" ? JSON.stringify(child) : write(child, inner, null);
+    return `[
+${value.map((child) => `${inner}${element(child)}`).join(",\n")}
+${pad}]`;
+  }
+  const entries = Object.entries(value).filter(([, child]) => child !== void 0);
+  if (entries.length === 0)
+    return "{}";
+  return `{
+${entries.map(([name, child]) => `${inner}${JSON.stringify(name)}: ${write(child, inner, name)}`).join(",\n")}
+${pad}}`;
+}
+function formatLibraryFile(value) {
+  return `${write(value, "", null)}
+`;
+}
+
+// packages/zaku/dist/lib/repositories/library-snapshot.js
+async function readText(path2) {
+  try {
+    return await readFile2(path2, "utf8");
+  } catch (error62) {
+    if (error62.code === "ENOENT")
+      return null;
+    throw error62;
+  }
+}
+async function writeText(path2, text) {
+  const temporary = `${path2}.${process.pid}.tmp`;
+  await writeFile2(temporary, text);
+  await rename2(temporary, path2);
+}
+async function readLibrarySnapshot(paths) {
+  const index = await readOptionalDesignFile(paths.libraryIndex, libraryIndexSchema);
+  if (!index)
+    return paths.legacyLibrary ? readOptionalDesignFile(paths.legacyLibrary, librarySnapshotSchema) : null;
+  const files2 = /* @__PURE__ */ new Map();
+  for (const component2 of index.components) {
+    const path2 = join3(paths.library, component2.file);
+    const text = await readText(path2);
+    if (text === null)
+      throw new DesignFileInvalid(path2, ["the index names it and it is missing; run zaku library save"]);
+    const file2 = parseDesignFile(path2, text, libraryFileSchema);
+    const keys = file2.variants.map((variant) => variant.key);
+    if (keys.join("\n") !== component2.variants.map((variant) => variant.key).join("\n")) {
+      throw new DesignFileInvalid(path2, ["its variants are not the index's; run zaku library save"]);
+    }
+    files2.set(component2.file, file2);
+  }
+  return joinLibrary(index, files2);
+}
+async function writeLibrarySnapshot(paths, snapshot) {
+  const { index, files: files2 } = splitLibrary(snapshot);
+  const directory = join3(paths.library, "components");
+  await mkdir(directory, { recursive: true });
+  const written = [];
+  let unchanged = 0;
+  for (const [file2, content] of files2) {
+    const path2 = join3(paths.library, file2);
+    const text = formatLibraryFile(content);
+    if (await readText(path2) === text) {
+      unchanged += 1;
+      continue;
+    }
+    await writeText(path2, text);
+    written.push(file2);
+  }
+  const removed = [];
+  for (const name of (await readdir(directory)).sort()) {
+    const file2 = `components/${name}`;
+    if (!name.endsWith(".json") || files2.has(file2))
+      continue;
+    await rm(join3(directory, name));
+    removed.push(file2);
+  }
+  await writeText(paths.libraryIndex, formatLibraryFile(index));
+  if (paths.legacyLibrary && await readText(paths.legacyLibrary) !== null) {
+    await rm(paths.legacyLibrary);
+    removed.push(relative(paths.root, paths.legacyLibrary));
+  }
+  return { written, unchanged, removed };
+}
+async function writeKitSnapshot(paths, kit) {
+  await mkdir(paths.library, { recursive: true });
+  const path2 = join3(paths.library, "kit.json");
+  await writeText(path2, formatLibraryFile(kit));
+  return path2;
+}
+async function readDesignSnapshots(paths, config2) {
+  const graph = designGraph(config2);
+  const libraries = {};
+  const kits = {};
+  const errors = [];
+  const attempt = async (read) => {
+    try {
+      await read();
+    } catch (error62) {
+      if (!(error62 instanceof DesignFileInvalid))
+        throw error62;
+      errors.push(error62);
+    }
+  };
+  for (const library of graph.libraries) {
+    await attempt(async () => {
+      const snapshot = await readLibrarySnapshot(librarySnapshotDir(paths, graph.legacy ? null : library.key));
+      if (snapshot)
+        libraries[library.key] = snapshot;
+    });
+  }
+  for (const kit of graph.kits) {
+    await attempt(async () => {
+      const path2 = join3(librarySnapshotDir(paths, kit.key).library, "kit.json");
+      const snapshot = await readOptionalDesignFile(path2, kitSnapshotSchema);
+      if (snapshot)
+        kits[kit.key] = snapshot;
+    });
+  }
+  return { libraries, kits, errors };
+}
+
 // packages/zaku/dist/lib/adapters/figma-rest-library.js
 var DOCUMENTATION_PREFIXES = ["DS/"];
 var round3 = (value) => Math.round(value * 1e4) / 1e4;
@@ -44945,6 +45516,23 @@ function strokeWeightsOf(node2) {
   const weight = node2.strokeWeight ?? 0;
   return [weight, weight, weight, weight];
 }
+function aliasIds(node2) {
+  const out = [];
+  const visit2 = (value) => {
+    if (Array.isArray(value))
+      value.forEach(visit2);
+    else if (value && typeof value === "object") {
+      if ("id" in value && typeof value.id === "string")
+        out.push(value.id.replace(/^VariableID:/, ""));
+      else
+        Object.values(value).forEach(visit2);
+    }
+  };
+  visit2(node2.boundVariables);
+  for (const paint of [...node2.fills ?? [], ...node2.strokes ?? []])
+    visit2(paint.boundVariables);
+  return [...new Set(out)];
+}
 var GLYPH_TYPES = /* @__PURE__ */ new Set(["VECTOR", "BOOLEAN_OPERATION", "LINE", "ELLIPSE", "POLYGON", "STAR"]);
 function glyphOf(instance, at) {
   let text = false;
@@ -44984,6 +45572,9 @@ function itemsOf(root, at) {
     const textStyle = node2.styles?.["text"];
     const glyph = path2 !== "" && node2.type === "INSTANCE" ? glyphOf(node2, at) : null;
     const componentId = node2.type === "INSTANCE" ? node2.componentId : path2 === "" ? node2.id : void 0;
+    const variableIds = aliasIds(node2);
+    const effectStyle = node2.styles?.["effect"];
+    const effectStyleKey = effectStyle ? at.entry.styles[effectStyle]?.key : void 0;
     out.push({
       nodeId: node2.id,
       path: path2,
@@ -45008,7 +45599,9 @@ function itemsOf(root, at) {
         textColor: isText ? fill.binding : null,
         radius: radiusName,
         ...glyph?.value ? { glyph: glyph.binding } : {}
-      }
+      },
+      ...variableIds.length > 0 ? { variableIds } : {},
+      ...effectStyleKey ? { effectStyleKey } : {}
     });
     if (path2 === "" || node2.type !== "INSTANCE") {
       for (const child of node2.children ?? [])
@@ -45027,28 +45620,55 @@ function asPublished(component2) {
     containing_frame: { pageName: component2.page }
   };
 }
+function viewBranch(view, branches) {
+  const prefix = view?.split(" / ")[0];
+  return view?.includes(" / ") && prefix !== void 0 && branches.includes(prefix) ? prefix : void 0;
+}
+function viewsByPage(document) {
+  return new Map((document.children ?? []).map((page) => [
+    page.name,
+    (page.children ?? []).flatMap((view) => view.absoluteBoundingBox ? [{ name: view.name, box: view.absoluteBoundingBox }] : [])
+  ]));
+}
+function viewHolding(views, box) {
+  if (!box)
+    return void 0;
+  return views.find(({ box: view }) => box.x >= view.x && box.y >= view.y && box.x < view.x + view.width && box.y < view.y + view.height)?.name;
+}
 async function readLibrary(options) {
-  const { rest, fileKey: fileKey2, part } = options;
+  const { rest, fileKey: fileKey3, part } = options;
+  const branches = options.branches ?? [];
+  const multiBranch = branches.length > 1;
+  const exported = new Map((part.components ?? []).map((component2) => [component2.id, component2.frame]));
   const listed = part.components ? {
     sets: part.components.filter((component2) => component2.set).map(asPublished),
     components: part.components.filter((component2) => !component2.set).map(asPublished)
-  } : await rest.published(fileKey2);
+  } : await rest.published(fileKey3);
   const published = [
     ...listed.sets,
     ...listed.components.filter((component2) => !component2.containing_frame?.containingComponentSet)
   ].filter((meta3) => !DOCUMENTATION_PREFIXES.some((prefix) => meta3.name.startsWith(prefix)));
-  const file2 = await rest.file(fileKey2, 1);
-  const response = published.length > 0 ? await rest.nodes(fileKey2, published.map((meta3) => meta3.node_id)) : { version: file2.version, nodes: {} };
+  const file2 = await rest.file(fileKey3, multiBranch ? 2 : 1);
+  const views = multiBranch ? viewsByPage(file2.document) : /* @__PURE__ */ new Map();
+  const response = published.length > 0 ? await rest.nodes(fileKey3, published.map((meta3) => meta3.node_id)) : { version: file2.version, nodes: {} };
   const components = [];
+  const localComponents = /* @__PURE__ */ new Set();
+  for (const entry of Object.values(response.nodes))
+    for (const meta3 of Object.values(entry?.components ?? {}))
+      if (meta3.remote === false)
+        localComponents.add(meta3.key);
   for (const meta3 of published) {
     const entry = response.nodes[meta3.node_id];
     if (!entry)
       continue;
     const variantNodes = entry.document.type === "COMPONENT_SET" ? (entry.document.children ?? []).filter((child) => child.type === "COMPONENT") : [entry.document];
+    const view = exported.has(meta3.node_id) ? exported.get(meta3.node_id) : viewHolding(views.get(meta3.containing_frame?.pageName ?? "") ?? [], entry.document.absoluteBoundingBox);
+    const branch = multiBranch ? viewBranch(view, branches) : void 0;
     components.push({
       name: meta3.name,
       key: meta3.key,
       page: (meta3.containing_frame?.pageName ?? "").replace(/^\W+\s*/, ""),
+      ...branch ? { branch } : {},
       ...descriptionMap(meta3.description),
       variants: variantNodes.map((variant) => ({
         key: entry.components[variant.id]?.key ?? "",
@@ -45062,11 +45682,16 @@ async function readLibrary(options) {
     });
   }
   return {
-    source: fileKey2,
+    source: fileKey3,
     version: file2.version,
     exportedAt: part.exportedAt,
     components,
     textStyles: part.textStyles,
+    ...part.variableKeys ? {
+      variableKeys: part.variableKeys,
+      effectStyles: part.effectStyles ?? [],
+      localComponents: [...localComponents].sort()
+    } : {},
     tokens: part.tokens.map((token) => ({
       combo: token.combo,
       values: Object.fromEntries(Object.entries(token.values).map(([name, value]) => [
@@ -45076,18 +45701,57 @@ async function readLibrary(options) {
     }))
   };
 }
+async function readKit(options) {
+  const components = await options.rest.components(options.key);
+  return {
+    key: options.key,
+    family: options.family,
+    components: components.map((component2) => ({ key: component2.key, name: component2.name }))
+  };
+}
 
 // packages/zaku/dist/lib/handlers/save-library.js
+function librarySaveTarget(config2, key) {
+  const graph = designGraph(config2);
+  const keys = [...graph.libraries, ...graph.kits].map((file2) => file2.key);
+  if (keys.length === 0) {
+    const byRole2 = config2.figma.libraries !== void 0 || config2.figma.kits !== void 0;
+    throw new FigmaFileKeyMissing(byRole2 ? "figma.libraries" : "figma.library");
+  }
+  const library = key === void 0 ? graph.libraries.length === 1 ? graph.libraries[0] : void 0 : void 0;
+  if (library)
+    return { kind: "library", library, legacy: graph.legacy };
+  if (key === void 0)
+    throw new LibraryKeyMissing(keys);
+  const named = graph.libraries.find((candidate) => candidate.key === key);
+  if (named)
+    return { kind: "library", library: named, legacy: graph.legacy };
+  const kit = graph.kits.find((candidate) => candidate.key === key);
+  if (kit)
+    return { kind: "kit", kit };
+  throw new LibraryKeyMissing(keys, key);
+}
 async function saveLibrary(options) {
   const paths = designPaths(options.root);
   const config2 = await readDesignFile(paths.config, zakuConfigSchema);
-  const fileKey2 = config2.figma.library;
-  if (fileKey2 === void 0)
-    throw new FigmaFileKeyMissing("figma.library");
-  const snapshot = librarySnapshotSchema.parse(await readLibrary({ rest: options.rest, fileKey: fileKey2, part: options.part }));
-  await writeFile2(paths.library, `${JSON.stringify(snapshot, null, 2)}
-`);
-  return snapshot;
+  const target = librarySaveTarget(config2, options.key);
+  if (target.kind === "kit") {
+    const at2 = librarySnapshotDir(paths, target.kit.key);
+    const kit = await readKit({ rest: options.rest, key: target.kit.key, family: target.kit.family });
+    await writeKitSnapshot(at2, kit);
+    return { kind: "kit", dir: relative2(paths.root, at2.library), kit };
+  }
+  if (!options.part)
+    throw new TypeError(`saving library ${target.library.key} needs the variables export`);
+  const { key, branches } = target.library;
+  const at = librarySnapshotDir(paths, target.legacy ? null : key);
+  const snapshot = librarySnapshotSchema.parse(await readLibrary({ rest: options.rest, fileKey: key, part: options.part, branches }));
+  return {
+    kind: "library",
+    dir: relative2(paths.root, at.library),
+    snapshot,
+    ...await writeLibrarySnapshot(at, snapshot)
+  };
 }
 var SaveLibraryHandler = class SaveLibraryHandler2 {
   rest;
@@ -45096,7 +45760,12 @@ var SaveLibraryHandler = class SaveLibraryHandler2 {
     this.rest = rest;
   }
   handle(command) {
-    return saveLibrary({ root: command.root, part: command.part, rest: this.rest });
+    return saveLibrary({
+      root: command.root,
+      rest: this.rest,
+      ...command.key !== void 0 ? { key: command.key } : {},
+      ...command.part !== void 0 ? { part: command.part } : {}
+    });
   }
 };
 SaveLibraryHandler = __decorate2([
@@ -45106,9 +45775,10 @@ SaveLibraryHandler = __decorate2([
 
 // packages/zaku/dist/lib/handlers/write-outline.js
 var import_tsyringe4 = __toESM(require_cjs(), 1);
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
 var import_yaml2 = __toESM(require_dist(), 1);
-import { mkdir, rm, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname2 } from "node:path";
+import { mkdir as mkdir2, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname2, join as join6 } from "node:path";
 
 // packages/zaku/dist/lib/domain/documentation-measures.js
 var COVER = {
@@ -45496,8 +46166,8 @@ var DOCUMENTATION_PARTS = [
 
 // packages/zaku/dist/lib/repositories/feature-maps.js
 import { createHash } from "node:crypto";
-import { readdir, readFile as readFile2 } from "node:fs/promises";
-import { basename, join as join3 } from "node:path";
+import { readdir as readdir2, readFile as readFile3 } from "node:fs/promises";
+import { basename, join as join4 } from "node:path";
 
 // packages/zaku/dist/lib/domain/feature-map.js
 var slug = external_exports.string().regex(/^[a-z][a-z0-9-]*$/, "lowercase letters, digits and dashes, starting with a letter");
@@ -45565,7 +46235,7 @@ function digestOf(text) {
 async function loadMaps(dir) {
   let names;
   try {
-    names = (await readdir(dir)).filter((name) => name.endsWith(".yaml")).sort();
+    names = (await readdir2(dir)).filter((name) => name.endsWith(".yaml")).sort();
   } catch (error62) {
     if (error62.code === "ENOENT")
       return { maps: [], errors: [] };
@@ -45574,8 +46244,8 @@ async function loadMaps(dir) {
   const maps = [];
   const errors = [];
   for (const name of names) {
-    const path2 = join3(dir, name);
-    const text = await readFile2(path2, "utf8");
+    const path2 = join4(dir, name);
+    const text = await readFile3(path2, "utf8");
     try {
       const map2 = parseDesignFile(path2, text, featureMapSchema);
       if (`${map2.feature}.yaml` !== basename(path2)) {
@@ -45616,6 +46286,9 @@ function indexTitles(maps) {
   return { titles, duplicates };
 }
 
+// packages/zaku/dist/lib/adapters/figma-rest-outline.js
+import { createHash as createHash2 } from "node:crypto";
+
 // packages/zaku/dist/lib/domain/layer-names.js
 var DEFAULT_NAMES = {
   FRAME: ["Frame"],
@@ -45684,7 +46357,7 @@ function outlineFrame(frame, where, ctx) {
   const images2 = [];
   const defaultNames = [];
   const links = [];
-  const relative = (node2) => {
+  const relative3 = (node2) => {
     const box = node2.absoluteBoundingBox;
     return box ? { x: box.x - origin.x, y: box.y - origin.y, width: box.width, height: box.height } : null;
   };
@@ -45713,7 +46386,7 @@ function outlineFrame(frame, where, ctx) {
           componentKey: ctx.components[child.componentId ?? ""]?.key ?? "",
           component: component2,
           interactive: ctx.interactive.has(component2),
-          bounds: relative(child)
+          bounds: relative3(child)
         });
       } else if (child.type === "TEXT") {
         instance.texts.push({
@@ -45754,7 +46427,7 @@ function outlineFrame(frame, where, ctx) {
       texts: [],
       interactive: ctx.interactive.has(component2),
       local: meta3?.remote === false,
-      bounds: relative(node2),
+      bounds: relative3(node2),
       sizing: {
         horizontal: node2.layoutSizingHorizontal ?? "FIXED",
         vertical: node2.layoutSizingVertical ?? "FIXED"
@@ -45803,6 +46476,17 @@ function outlineFrame(frame, where, ctx) {
   links.push(...linksOf(frame));
   for (const child of shown(frame))
     walk(child);
+  const drawn = {
+    size: [origin.width, origin.height],
+    instances: instances.map((instance) => [
+      instance.componentKey,
+      instance.variant,
+      instance.properties,
+      instance.texts.map((text) => text.characters),
+      instance.bounds
+    ]),
+    texts: texts.map((text) => text.characters)
+  };
   return {
     nodeId: frame.id,
     name: frame.name,
@@ -45816,13 +46500,14 @@ function outlineFrame(frame, where, ctx) {
     raw,
     images: images2,
     defaultNames,
-    links
+    links,
+    digest: createHash2("sha256").update(JSON.stringify(drawn)).digest("hex").slice(0, 16)
   };
 }
 
 // packages/zaku/dist/lib/repositories/outlines.js
-import { readdir as readdir2 } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { readdir as readdir3 } from "node:fs/promises";
+import { join as join5 } from "node:path";
 
 // packages/zaku/dist/lib/domain/outline.js
 var boundsSchema = external_exports.object({ x: external_exports.number(), y: external_exports.number(), width: external_exports.number(), height: external_exports.number() }).strict();
@@ -45882,43 +46567,103 @@ var frameOutlineSchema = external_exports.object({
   raw: external_exports.array(rawOutlineSchema),
   images: external_exports.array(imageOutlineSchema),
   defaultNames: external_exports.array(external_exports.object({ nodeId: external_exports.string(), name: external_exports.string() }).strict()),
-  links: external_exports.array(linkOutlineSchema)
+  links: external_exports.array(linkOutlineSchema),
+  /** In a product file of one page per screen: the page the frame is on, and the product file it is in. */
+  page: external_exports.string().optional(),
+  source: external_exports.string().optional(),
+  /** What the frame draws, without its node ids, so a copy and its source digest alike. */
+  digest: external_exports.string().optional()
+}).strict();
+var flowOutlineSchema = external_exports.object({
+  /** The Figma file key the page is in. */
+  source: external_exports.string(),
+  page: external_exports.string(),
+  fileVersion: external_exports.string(),
+  frames: external_exports.array(external_exports.object({
+    nodeId: external_exports.string(),
+    name: external_exports.string(),
+    screen: external_exports.string().nullable(),
+    target: external_exports.string(),
+    state: external_exports.string(),
+    start: external_exports.boolean(),
+    links: external_exports.array(linkOutlineSchema),
+    digest: external_exports.string()
+  }).strict())
 }).strict();
-var screenOutlineSchema = external_exports.object({
+var LEGACY_LIBRARY_VERSION = "figma.library";
+function legacyVersion(value) {
+  if (value === null || typeof value !== "object" || !("libraryVersion" in value))
+    return value;
+  const { libraryVersion, ...rest } = value;
+  return {
+    ...rest,
+    libraryVersions: typeof libraryVersion === "string" ? { [LEGACY_LIBRARY_VERSION]: libraryVersion } : {}
+  };
+}
+var screenOutlineSchema = external_exports.preprocess(legacyVersion, external_exports.object({
   feature: external_exports.string(),
   screen: external_exports.string(),
   /** The Figma file key the frames were read from. */
   source: external_exports.string(),
   fileVersion: external_exports.string(),
   mapDigest: external_exports.string(),
-  libraryVersion: external_exports.string().nullable(),
+  /** The version of each library snapshot the frames were read against, by key. */
+  libraryVersions: external_exports.record(external_exports.string(), external_exports.string()),
+  /** The version of every product file zaku.yaml lists, when it lists them by platform. */
+  fileVersions: external_exports.record(external_exports.string(), external_exports.string()).optional(),
   frames: external_exports.array(frameOutlineSchema)
-}).strict();
+}).strict());
 var unmappedSchema = external_exports.object({
   fileVersion: external_exports.string(),
-  frames: external_exports.array(external_exports.object({ nodeId: external_exports.string(), name: external_exports.string() }).strict())
+  frames: external_exports.array(external_exports.object({ nodeId: external_exports.string(), name: external_exports.string() }).strict()),
+  /** A component drawn on a product page, which belongs in a Components library. */
+  components: external_exports.array(external_exports.object({ nodeId: external_exports.string(), name: external_exports.string(), page: external_exports.string(), source: external_exports.string() }).strict()).optional()
 }).strict();
 
 // packages/zaku/dist/lib/repositories/outlines.js
+var FLOWS_DIR = "flows";
+function flowOutlinePath(dir, source, page) {
+  const slug2 = page.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "page";
+  return join5(dir, FLOWS_DIR, source, `${slug2}.yaml`);
+}
 function outlinePath(dir, feature, screen) {
-  return join4(dir, feature, `${screen}.yaml`);
+  return join5(dir, feature, `${screen}.yaml`);
 }
 async function loadOutlines(dir) {
   const outlines = [];
+  const flows = [];
   const errors = [];
   let features;
   try {
-    features = (await readdir2(dir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+    features = (await readdir3(dir, { withFileTypes: true })).filter((entry) => entry.isDirectory() && entry.name !== FLOWS_DIR).map((entry) => entry.name).sort();
   } catch (error62) {
     if (error62.code === "ENOENT")
-      return { outlines, unmapped: null, errors };
+      return { outlines, flows, unmapped: null, errors };
     throw error62;
   }
   for (const feature of features) {
-    const files2 = (await readdir2(join4(dir, feature))).filter((name) => name.endsWith(".yaml")).sort();
+    const files2 = (await readdir3(join5(dir, feature))).filter((name) => name.endsWith(".yaml")).sort();
+    for (const file2 of files2) {
+      try {
+        outlines.push(await readDesignFile(join5(dir, feature, file2), screenOutlineSchema));
+      } catch (error62) {
+        if (error62 instanceof DesignFileInvalid)
+          errors.push(error62);
+        else
+          throw error62;
+      }
+    }
+  }
+  const sources = await readdir3(join5(dir, FLOWS_DIR)).catch((error62) => {
+    if (error62.code === "ENOENT")
+      return [];
+    throw error62;
+  });
+  for (const source of sources.sort()) {
+    const files2 = (await readdir3(join5(dir, FLOWS_DIR, source))).filter((name) => name.endsWith(".yaml")).sort();
     for (const file2 of files2) {
       try {
-        outlines.push(await readDesignFile(join4(dir, feature, file2), screenOutlineSchema));
+        flows.push(await readDesignFile(join5(dir, FLOWS_DIR, source, file2), flowOutlineSchema));
       } catch (error62) {
         if (error62 instanceof DesignFileInvalid)
           errors.push(error62);
@@ -45929,14 +46674,14 @@ async function loadOutlines(dir) {
   }
   let unmapped = null;
   try {
-    unmapped = await readOptionalDesignFile(join4(dir, "unmapped.yaml"), unmappedSchema);
+    unmapped = await readOptionalDesignFile(join5(dir, "unmapped.yaml"), unmappedSchema);
   } catch (error62) {
     if (error62 instanceof DesignFileInvalid)
       errors.push(error62);
     else
       throw error62;
   }
-  return { outlines, unmapped, errors };
+  return { outlines, flows, unmapped, errors };
 }
 
 // packages/zaku/dist/lib/handlers/write-outline.js
@@ -45973,108 +46718,215 @@ function resolveFrame(frame, parsed, maps) {
     return candidates.find((ref) => ref.feature === pageFeature);
   return candidates.length === 1 ? candidates[0] : void 0;
 }
+function resolveTitle(parsed, maps) {
+  const candidates = [...indexScreens(maps).values()].filter((ref) => ref.screen.title === parsed.title);
+  return candidates.length === 1 ? candidates[0] : void 0;
+}
 function looksLikeScreenFrame(name) {
   return name.includes("/");
 }
-function holdsScreens(page) {
+function holdsScreens(page, prototypes = /* @__PURE__ */ new Set()) {
   if (page === COVER.page || page === DOCUMENTATION_COMPONENTS_PAGE || page === DIRECTIONS_PAGE)
     return false;
+  if (prototypes.has(page))
+    return false;
   return !page.startsWith("\u2756 ") && !page.includes(" / ") && !/^-+$/.test(page);
 }
+function listComponents(document, source) {
+  const out = [];
+  for (const page of document.children ?? []) {
+    if (page.type !== "CANVAS" || !holdsScreens(page.name))
+      continue;
+    const walk = (node2) => {
+      for (const child of node2.children ?? []) {
+        if (child.type === "COMPONENT" || child.type === "COMPONENT_SET")
+          out.push({ nodeId: child.id, name: child.name, page: page.name, source });
+        else if (child.type === "SECTION")
+          walk(child);
+      }
+    };
+    walk(page);
+  }
+  return out;
+}
+function productFiles(config2) {
+  const graph = designGraph(config2);
+  if (graph.legacy)
+    return config2.figma.product === void 0 ? [] : [{ key: config2.figma.product, targets: config2.targets }];
+  return graph.products.map((product) => ({
+    key: product.key,
+    targets: config2.targets.filter((target) => graph.platformOf(target) === product.platform)
+  }));
+}
 async function runOutline(options) {
   const paths = designPaths(options.root);
   const config2 = await readDesignFile(paths.config, zakuConfigSchema);
-  const fileKey2 = config2.figma.product;
-  if (fileKey2 === void 0)
-    throw new FigmaFileKeyMissing("figma.product");
+  const { libraries: listed, kits, products: byPlatform, prototypes: flows } = config2.figma;
+  const legacy = [listed, kits, byPlatform, flows].every((files2) => files2 === void 0);
+  const products = productFiles(config2);
+  if (products.length === 0)
+    throw new FigmaFileKeyMissing(legacy ? "figma.product" : "figma.products");
   const { maps, errors } = await loadMaps(paths.maps);
   if (errors[0])
     throw errors[0];
   const digests = new Map(maps.map((loaded) => [loaded.map.feature, loaded.digest]));
-  const library = await readOptionalDesignFile(paths.library, librarySnapshotSchema);
+  const { libraries } = await readDesignSnapshots(paths, config2);
+  const libraryVersions = Object.fromEntries(Object.entries(libraries).map(([key, library]) => [key, library.version]));
   const existing = await loadOutlines(paths.outline);
-  const file2 = await options.rest.file(fileKey2, INDEX_DEPTH);
-  const listed = listFrames(file2.document);
+  const prototypes = new Set(legacy ? config2.targets.map((target) => `${target.name} prototype`) : []);
+  const versions = {};
+  const flowPages = /* @__PURE__ */ new Map();
+  const flowFrame = (source, frame, targets) => {
+    const parsed = parseFrameName(frame.name, targets);
+    if (!parsed)
+      return;
+    const key = `${source}
+${frame.page}`;
+    const page = flowPages.get(key) ?? { source, page: frame.page, frames: [] };
+    page.frames.push({ frame, parsed });
+    flowPages.set(key, page);
+  };
   const resolved = /* @__PURE__ */ new Map();
-  const unmapped = { fileVersion: file2.version, frames: [] };
-  for (const frame of listed.filter((listed2) => holdsScreens(listed2.page))) {
-    const parsed = parseFrameName(frame.name, config2.targets);
-    if (!parsed) {
-      if (looksLikeScreenFrame(frame.name))
+  const unmapped = { fileVersion: "", frames: [] };
+  const components = [];
+  for (const product of products) {
+    const file2 = await options.rest.file(product.key, INDEX_DEPTH);
+    versions[product.key] = file2.version;
+    const listed2 = listFrames(file2.document);
+    for (const frame of listed2.filter((candidate) => prototypes.has(candidate.page)))
+      flowFrame(product.key, frame, product.targets);
+    for (const frame of listed2.filter((candidate) => holdsScreens(candidate.page, prototypes))) {
+      const parsed = parseFrameName(frame.name, product.targets);
+      if (!parsed) {
+        if (looksLikeScreenFrame(frame.name))
+          unmapped.frames.push({ nodeId: frame.id, name: frame.name });
+        continue;
+      }
+      const ref = legacy ? resolveFrame(frame, parsed, maps) : resolveTitle(parsed, maps);
+      if (ref)
+        resolved.set(frame.id, { frame, parsed, ref, source: product.key });
+      else
         unmapped.frames.push({ nodeId: frame.id, name: frame.name });
-      continue;
     }
-    const ref = resolveFrame(frame, parsed, maps);
-    if (ref)
-      resolved.set(frame.id, { frame, parsed, ref });
-    else
-      unmapped.frames.push({ nodeId: frame.id, name: frame.name });
+    if (!legacy)
+      components.push(...listComponents(file2.document, product.key));
+  }
+  const graph = designGraph(config2);
+  for (const file2 of legacy ? [] : graph.prototypes) {
+    const read = await options.rest.file(file2.key, INDEX_DEPTH);
+    versions[file2.key] = read.version;
+    const targets = config2.targets.filter((target) => graph.platformOf(target) === file2.platform);
+    for (const frame of listFrames(read.document).filter((candidate) => holdsScreens(candidate.page)))
+      flowFrame(file2.key, frame, targets);
   }
+  unmapped.fileVersion = Object.values(versions).join(",");
+  if (!legacy)
+    unmapped.components = components;
   const outlined = new Set(existing.outlines.flatMap((outline) => outline.frames.map((frame) => frame.nodeId)));
   const drawnScreens = new Set([...resolved.values()].map(({ ref }) => `${ref.feature}/${ref.id}`));
-  const current = existing.outlines.every((outline) => outline.fileVersion === file2.version && outline.mapDigest === digests.get(outline.feature) && outline.libraryVersion === (library?.version ?? null)) && [...resolved.keys()].every((id2) => outlined.has(id2)) && existing.outlines.every((outline) => drawnScreens.has(`${outline.feature}/${outline.screen}`));
+  const current = existing.outlines.every((outline) => (legacy ? outline.fileVersion === versions[outline.source] : isDeepStrictEqual2(outline.fileVersions, versions)) && outline.mapDigest === digests.get(outline.feature) && isDeepStrictEqual2(outline.libraryVersions, libraryVersions)) && [...resolved.keys()].every((id2) => outlined.has(id2)) && existing.flows.length === flowPages.size && existing.flows.every((flow) => flow.fileVersion === versions[flow.source]) && existing.outlines.every((outline) => drawnScreens.has(`${outline.feature}/${outline.screen}`));
   if (options.frames === null && existing.outlines.length > 0 && current) {
     return { skipped: true, read: 0, written: [], unmapped: unmapped.frames.length };
   }
   const ids = options.frames ?? [...resolved.keys()];
-  const response = ids.length > 0 ? await options.rest.nodes(fileKey2, ids) : { version: file2.version, nodes: {} };
   const byScreen = /* @__PURE__ */ new Map();
   if (options.frames !== null) {
     for (const outline of existing.outlines)
       byScreen.set(`${outline.feature}/${outline.screen}`, outline);
   }
   const interactive = new Set(config2.interactive);
-  const resized = new Set(Object.values(response.nodes).flatMap((entry) => entry ? resizedLocalComponents(entry.document, entry.components) : []));
-  const sizes = /* @__PURE__ */ new Map();
-  if (resized.size > 0) {
-    const read = await options.rest.nodes(fileKey2, [...resized]);
-    for (const [id2, entry] of Object.entries(read.nodes)) {
-      const box = entry?.document.absoluteBoundingBox;
-      if (box)
-        sizes.set(id2, { width: box.width, height: box.height });
-    }
-  }
-  for (const [id2, entry] of Object.entries(response.nodes)) {
-    const found = resolved.get(id2);
-    if (!entry || !found)
+  for (const product of products) {
+    const own2 = ids.filter((id2) => resolved.has(id2) ? resolved.get(id2)?.source === product.key : product === products[0]);
+    if (own2.length === 0)
       continue;
-    const { frame: place, parsed, ref } = found;
-    const key = `${ref.feature}/${ref.id}`;
-    const outline = byScreen.get(key) ?? {
-      feature: ref.feature,
-      screen: ref.id,
-      source: fileKey2,
-      fileVersion: file2.version,
-      mapDigest: "",
-      libraryVersion: null,
-      frames: []
-    };
-    const frame = outlineFrame(entry.document, {
-      target: parsed.target.id,
-      state: parsed.state,
-      containers: place.containers,
-      start: place.start
-    }, { ...entry, interactive, sizes });
-    outline.frames = [...outline.frames.filter((kept) => kept.nodeId !== id2), frame].sort((a, b) => a.name.localeCompare(b.name));
-    outline.fileVersion = file2.version;
-    outline.mapDigest = digests.get(ref.feature) ?? "";
-    outline.libraryVersion = library?.version ?? null;
-    byScreen.set(key, outline);
+    const response = await options.rest.nodes(product.key, own2);
+    const resized = new Set(Object.values(response.nodes).flatMap((entry) => entry ? resizedLocalComponents(entry.document, entry.components) : []));
+    const sizes = /* @__PURE__ */ new Map();
+    if (resized.size > 0) {
+      const read = await options.rest.nodes(product.key, [...resized]);
+      for (const [id2, entry] of Object.entries(read.nodes)) {
+        const box = entry?.document.absoluteBoundingBox;
+        if (box)
+          sizes.set(id2, { width: box.width, height: box.height });
+      }
+    }
+    for (const [id2, entry] of Object.entries(response.nodes)) {
+      const found = resolved.get(id2);
+      if (!entry || !found)
+        continue;
+      const { frame: place, parsed, ref } = found;
+      const key = `${ref.feature}/${ref.id}`;
+      const outline = byScreen.get(key) ?? {
+        feature: ref.feature,
+        screen: ref.id,
+        source: product.key,
+        fileVersion: versions[product.key] ?? "",
+        mapDigest: "",
+        libraryVersions: {},
+        frames: []
+      };
+      const frame = outlineFrame(entry.document, {
+        target: parsed.target.id,
+        state: parsed.state,
+        containers: place.containers,
+        start: place.start
+      }, { ...entry, interactive, sizes });
+      if (!legacy)
+        Object.assign(frame, { page: place.page, source: product.key });
+      outline.frames = [...outline.frames.filter((kept) => kept.nodeId !== id2), frame].sort((a, b) => a.name.localeCompare(b.name));
+      outline.mapDigest = digests.get(ref.feature) ?? "";
+      outline.libraryVersions = libraryVersions;
+      if (legacy)
+        outline.fileVersion = versions[product.key] ?? "";
+      else
+        outline.fileVersions = versions;
+      byScreen.set(key, outline);
+    }
   }
   if (options.frames === null) {
+    await rm2(join6(paths.outline, FLOWS_DIR), { recursive: true, force: true });
+    for (const page of flowPages.values()) {
+      const response = await options.rest.nodes(page.source, page.frames.map(({ frame }) => frame.id));
+      const flow = {
+        source: page.source,
+        page: page.page,
+        fileVersion: versions[page.source] ?? "",
+        frames: []
+      };
+      for (const { frame, parsed } of page.frames) {
+        const entry = response.nodes[frame.id];
+        if (!entry)
+          continue;
+        const read = outlineFrame(entry.document, { target: parsed.target.id, state: parsed.state, containers: frame.containers, start: frame.start }, { ...entry, interactive, sizes: /* @__PURE__ */ new Map() });
+        const ref = resolveTitle(parsed, maps);
+        flow.frames.push({
+          nodeId: frame.id,
+          name: frame.name,
+          screen: ref ? `${ref.feature}/${ref.id}` : null,
+          target: parsed.target.id,
+          state: parsed.state,
+          start: frame.start,
+          links: read.links,
+          digest: read.digest ?? ""
+        });
+      }
+      const path2 = flowOutlinePath(paths.outline, page.source, page.page);
+      await mkdir2(dirname2(path2), { recursive: true });
+      await writeFile3(path2, (0, import_yaml2.stringify)(flow));
+    }
     for (const outline of existing.outlines) {
       if (!byScreen.has(`${outline.feature}/${outline.screen}`))
-        await rm(outlinePath(paths.outline, outline.feature, outline.screen), { force: true });
+        await rm2(outlinePath(paths.outline, outline.feature, outline.screen), { force: true });
     }
   }
   const written = [];
   for (const outline of byScreen.values()) {
     const path2 = outlinePath(paths.outline, outline.feature, outline.screen);
-    await mkdir(dirname2(path2), { recursive: true });
+    await mkdir2(dirname2(path2), { recursive: true });
     await writeFile3(path2, (0, import_yaml2.stringify)(outline));
     written.push(path2);
   }
-  await mkdir(paths.outline, { recursive: true });
+  await mkdir2(paths.outline, { recursive: true });
   await writeFile3(paths.unmapped, (0, import_yaml2.stringify)(unmapped));
   return {
     skipped: false,
@@ -46190,14 +47042,14 @@ RecipeRepository = __decorate2([
 
 // packages/zaku/dist/lib/repositories/json-schema-files.js
 var import_tsyringe10 = __toESM(require_cjs(), 1);
-import { mkdir as mkdir2 } from "node:fs/promises";
-import { join as join5 } from "node:path";
+import { mkdir as mkdir3 } from "node:fs/promises";
+import { join as join7 } from "node:path";
 var JsonSchemaFiles = class JsonSchemaFiles2 {
   async write(dir, schemas) {
-    await mkdir2(dir, { recursive: true });
+    await mkdir3(dir, { recursive: true });
     const written = [];
     for (const [name, schema] of Object.entries(schemas)) {
-      const path2 = join5(dir, name);
+      const path2 = join7(dir, name);
       await writeDesignFile(path2, schema);
       written.push(path2);
     }
@@ -46210,13 +47062,13 @@ JsonSchemaFiles = __decorate2([
 
 // packages/zaku/dist/lib/repositories/source-files.js
 var import_tsyringe11 = __toESM(require_cjs(), 1);
-import { readFile as readFile3 } from "node:fs/promises";
+import { readFile as readFile4 } from "node:fs/promises";
 var SourceFiles = class SourceFiles2 {
   readText(path2) {
-    return readFile3(path2, "utf8");
+    return readFile4(path2, "utf8");
   }
   async readJson(path2) {
-    return JSON.parse(await readFile3(path2, "utf8"));
+    return JSON.parse(await readFile4(path2, "utf8"));
   }
 };
 SourceFiles = __decorate2([
@@ -46224,11 +47076,11 @@ SourceFiles = __decorate2([
 ], SourceFiles);
 
 // packages/zaku/dist/lib/repositories/budget-ledger.js
-import { mkdir as mkdir3, readFile as readFile4, rename as rename2, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname3, join as join6 } from "node:path";
+import { mkdir as mkdir4, readFile as readFile5, rename as rename3, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname3, join as join8 } from "node:path";
 function ledgerPath(env, platform, home) {
-  const cache = env["XDG_CACHE_HOME"] ?? (platform === "darwin" ? join6(home, "Library", "Caches") : join6(home, ".cache"));
-  return join6(cache, "zaku", "ledger.json");
+  const cache = env["XDG_CACHE_HOME"] ?? (platform === "darwin" ? join8(home, "Library", "Caches") : join8(home, ".cache"));
+  return join8(cache, "zaku", "ledger.json");
 }
 function today(now) {
   return now.toISOString().slice(0, 10);
@@ -46238,7 +47090,7 @@ function seatAndRun(env) {
 }
 async function readLedger(path2, day) {
   try {
-    const parsed = JSON.parse(await readFile4(path2, "utf8"));
+    const parsed = JSON.parse(await readFile5(path2, "utf8"));
     const isCount = (seat) => {
       const count = seat;
       return typeof count === "object" && count !== null && typeof count.mcp === "number" && typeof count.rest === "number" && typeof count.runs === "object" && count.runs !== null && Object.values(count.runs).every((value) => typeof value === "number");
@@ -46257,11 +47109,11 @@ async function recordCalls(path2, entry) {
   if (entry.kind === "mcp")
     seat.runs[entry.run] = (seat.runs[entry.run] ?? 0) + entry.count;
   ledger.seats[entry.seat] = seat;
-  await mkdir3(dirname3(path2), { recursive: true });
+  await mkdir4(dirname3(path2), { recursive: true });
   const temporary = `${path2}.${process.pid}.tmp`;
   await writeFile4(temporary, `${JSON.stringify(ledger)}
 `);
-  await rename2(temporary, path2);
+  await rename3(temporary, path2);
   return ledger;
 }
 function mcpAllowance(ledger, seat, run, budget) {
@@ -46297,6 +47149,30 @@ var pairingSchema = external_exports.object({
 }).strict();
 var pairingsFileSchema = external_exports.object({ pairings: external_exports.array(pairingSchema.extend({ hash: external_exports.string() }).strict()) }).strict();
 
+// packages/zaku/dist/lib/domain/print-graph.js
+function printGraph(config2, snapshots) {
+  const graph = designGraph(config2);
+  const lines = ["targets"];
+  for (const target of config2.targets) {
+    const files2 = [
+      ...graph.librariesFor(target).map((library) => `${library.key} ${library.layer}`),
+      ...graph.kitsFor(target).map((kit) => `${kit.key} ${kit.family} kit`)
+    ];
+    const branch = graph.branchOf(target);
+    lines.push(`  ${target.name} (${target.id}, ${branch ? `branch ${branch}` : "no branch"}, ${graph.platformOf(target)}): ${files2.join(", ") || "nothing"}`);
+  }
+  lines.push("files");
+  const extendedBy = (key) => graph.libraries.filter((library) => library.extends.includes(key)).map((library) => library.key).join(", ") || "nothing";
+  const saved = (key, present) => present ? "" : ` (no snapshot; run zaku library save --key ${key})`;
+  for (const library of graph.libraries) {
+    lines.push(`  ${library.key} ${library.layer} [${library.branches.join(", ")}]: extends ${library.extends.join(", ") || "nothing"}; extended by ${extendedBy(library.key)}${saved(library.key, snapshots.libraries[library.key] !== void 0)}`);
+  }
+  for (const kit of graph.kits) {
+    lines.push(`  ${kit.key} ${kit.family} kit: extended by ${extendedBy(kit.key)}${saved(kit.key, snapshots.kits[kit.key] !== void 0)}`);
+  }
+  return lines;
+}
+
 // packages/zaku/dist/lib/adapters/figma-rest.js
 var FigmaRateLimited = class extends Error {
   url;
@@ -46341,26 +47217,30 @@ function createFigmaRest(options) {
     throw new FigmaRateLimited(url2);
   }
   const chunks = (ids) => Array.from({ length: Math.ceil(ids.length / BATCH) }, (_, index) => ids.slice(index * BATCH, (index + 1) * BATCH));
+  async function components(fileKey3) {
+    const listed = await call(`${BASE}/files/${fileKey3}/components`);
+    return listed.meta.components;
+  }
   return {
-    file: (fileKey2, depth) => call(`${BASE}/files/${fileKey2}?depth=${depth}`),
-    async nodes(fileKey2, ids) {
+    file: (fileKey3, depth) => call(`${BASE}/files/${fileKey3}?depth=${depth}`),
+    async nodes(fileKey3, ids) {
       const merged = { version: "", nodes: {} };
       for (const chunk of chunks(ids)) {
-        const part = await call(`${BASE}/files/${fileKey2}/nodes?ids=${encodeURIComponent(chunk.join(","))}`);
+        const part = await call(`${BASE}/files/${fileKey3}/nodes?ids=${encodeURIComponent(chunk.join(","))}`);
         merged.version = part.version;
         Object.assign(merged.nodes, part.nodes);
       }
       return merged;
     },
-    async published(fileKey2) {
-      const sets = await call(`${BASE}/files/${fileKey2}/component_sets`);
-      const components = await call(`${BASE}/files/${fileKey2}/components`);
-      return { sets: sets.meta.component_sets, components: components.meta.components };
+    async published(fileKey3) {
+      const sets = await call(`${BASE}/files/${fileKey3}/component_sets`);
+      return { sets: sets.meta.component_sets, components: await components(fileKey3) };
     },
-    async images(fileKey2, ids) {
+    components,
+    async images(fileKey3, ids) {
       const merged = {};
       for (const chunk of chunks(ids)) {
-        const part = await call(`${BASE}/images/${fileKey2}?ids=${encodeURIComponent(chunk.join(","))}&format=png&scale=1`);
+        const part = await call(`${BASE}/images/${fileKey3}?ids=${encodeURIComponent(chunk.join(","))}&format=png&scale=1`);
         Object.assign(merged, part.images);
       }
       return merged;
@@ -46370,17 +47250,40 @@ function createFigmaRest(options) {
 
 // packages/zaku/dist/lib/adapters/figma-variables-script.js
 async function exportVariables(figma, options) {
-  const collections = await figma.variables.getLocalVariableCollectionsAsync();
+  const collections = [...await figma.variables.getLocalVariableCollectionsAsync()];
+  if (!collections.some((collection) => collection.name === "semantic")) {
+    const available = await figma.teamLibrary.getAvailableLibraryVariableCollectionsAsync();
+    const bases = [
+      ...new Set(available.filter((entry) => entry.name === "semantic").map((entry) => entry.libraryName))
+    ];
+    if (bases.length === 0)
+      throw new Error("the file has no semantic collection and no enabled library has one");
+    if (bases.length > 1)
+      throw new Error(`several enabled libraries hold a semantic collection: ${bases.join(", ")}; enable only the one this library extends`);
+    const imported = /* @__PURE__ */ new Map();
+    for (const entry of available.filter((candidate) => candidate.libraryName === bases[0])) {
+      for (const listed of await figma.teamLibrary.getVariablesInLibraryCollectionAsync(entry.key)) {
+        const variable = await figma.variables.importVariableByKeyAsync(listed.key);
+        if (!imported.has(variable.variableCollectionId))
+          imported.set(variable.variableCollectionId, await figma.variables.getVariableCollectionByIdAsync(variable.variableCollectionId));
+      }
+    }
+    collections.push(...[...imported.values()].filter(Boolean));
+  }
   const semantic = collections.find((collection) => collection.name === "semantic");
   if (!semantic)
     throw new Error("the library has no semantic variable collection");
   const hex3 = (value) => Math.round(Math.min(1, Math.max(0, value)) * 255).toString(16).padStart(2, "0");
   const variables = {};
+  const variableKeys = {};
   for (const collection of collections) {
     for (const id2 of collection.variableIds) {
       const variable = await figma.variables.getVariableByIdAsync(id2);
-      if (variable)
-        variables[String(id2).replace(/^VariableID:/, "")] = variable.name;
+      if (!variable)
+        continue;
+      const short = String(id2).replace(/^VariableID:/, "");
+      variables[short] = variable.name;
+      variableKeys[short] = { key: variable.key, local: variable.remote !== true };
     }
   }
   const holder = figma.createFrame();
@@ -46402,6 +47305,8 @@ async function exportVariables(figma, options) {
       const values = {};
       for (const id2 of semantic.variableIds) {
         const variable = await figma.variables.getVariableByIdAsync(id2);
+        if (!variable)
+          continue;
         const resolved = variable.resolveForConsumer(holder).value;
         values[variable.name] = typeof resolved === "object" && resolved !== null ? `#${hex3(resolved.r)}${hex3(resolved.g)}${hex3(resolved.b)}${hex3(resolved.a ?? 1)}` : resolved;
       }
@@ -46421,21 +47326,31 @@ async function exportVariables(figma, options) {
         for (const node2 of page.findAllWithCriteria({ types: ["COMPONENT_SET", "COMPONENT"] })) {
           if (node2.type === "COMPONENT" && node2.parent?.type === "COMPONENT_SET")
             continue;
+          let view = node2;
+          while (view.parent && view.parent.type !== "PAGE")
+            view = view.parent;
           components.push({
             id: node2.id,
             key: node2.key,
             name: node2.name,
             page: page.name,
+            ...view !== node2 && view.parent ? { frame: view.name } : {},
             description: node2.description ?? "",
             set: node2.type === "COMPONENT_SET"
           });
         }
       }
     }
+    const effectStyles = (await figma.getLocalEffectStylesAsync()).map((style) => ({
+      key: style.key,
+      name: style.name
+    }));
     return {
       exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
       variables,
+      variableKeys,
       textStyles,
+      effectStyles,
       tokens,
       ...options.local ? { components } : {}
     };
@@ -47027,15 +47942,15 @@ async function startPluginBridge(options = {}) {
           });
     });
   });
-  function request(fileKey2, message, timeoutMs) {
+  function request(fileKey3, message, timeoutMs) {
     if (port === null)
       return Promise.resolve({
         ok: false,
         error: `no port from ${ports[0]} to ${ports[ports.length - 1]} was free, so zaku mcp could not listen for the plugin`
       });
-    const socket = holderOf(fileKey2);
+    const socket = holderOf(fileKey3);
     if (!socket)
-      return Promise.resolve({ ok: false, error: `file ${fileKey2} is not open in Figma with the zaku plugin` });
+      return Promise.resolve({ ok: false, error: `file ${fileKey3} is not open in Figma with the zaku plugin` });
     const id2 = `c${++next}`;
     return new Promise((resolve3) => {
       const timer = setTimeout(() => settle2(id2, { ok: false, error: `no answer from the zaku panel in ${timeoutMs / 1e3} s; ${PARTIAL}` }), timeoutMs);
@@ -47045,8 +47960,8 @@ async function startPluginBridge(options = {}) {
   }
   return {
     port,
-    run: (fileKey2, call, timeoutMs) => request(fileKey2, { type: "run", ...call }, timeoutMs),
-    screenshot: (fileKey2, call, timeoutMs) => request(fileKey2, { type: "screenshot", ...call }, timeoutMs),
+    run: (fileKey3, call, timeoutMs) => request(fileKey3, { type: "run", ...call }, timeoutMs),
+    screenshot: (fileKey3, call, timeoutMs) => request(fileKey3, { type: "screenshot", ...call }, timeoutMs),
     close: () => new Promise((done) => {
       if (!server || !bound)
         return done();
@@ -47057,12 +47972,66 @@ async function startPluginBridge(options = {}) {
   };
 }
 
+// packages/zaku/dist/lib/domain/checks/libraries.js
+var comboKey2 = (combo) => JSON.stringify(Object.entries(combo).sort(([a], [b]) => a.localeCompare(b)));
+function joinLibraries(snapshots) {
+  if (snapshots.length === 1 && snapshots[0])
+    return snapshots[0];
+  const tokens = /* @__PURE__ */ new Map();
+  for (const snapshot of snapshots) {
+    for (const token of snapshot.tokens) {
+      const key = comboKey2(token.combo);
+      tokens.set(key, { combo: token.combo, values: { ...tokens.get(key)?.values, ...token.values } });
+    }
+  }
+  return {
+    source: snapshots.map((snapshot) => snapshot.source).join(","),
+    version: snapshots.map((snapshot) => snapshot.version).join(","),
+    exportedAt: snapshots.map((snapshot) => snapshot.exportedAt).sort().at(-1) ?? "",
+    components: snapshots.flatMap((snapshot) => snapshot.components),
+    textStyles: snapshots.flatMap((snapshot) => snapshot.textStyles),
+    tokens: [...tokens.values()]
+  };
+}
+function missingSnapshots(graph, keys) {
+  const paths = keys.map((key) => graph.legacy ? "library/index.json" : `library/${key}/index.json`);
+  return `${paths.join(", ")} ${paths.length === 1 ? "is" : "are"} missing`;
+}
+function checkLibraries(input2) {
+  const graph = designGraph(input2.config);
+  const { libraries, missing } = snapshotsFor(input2);
+  const kits = new Set(graph.kits.map((kit) => kit.key));
+  const absent = missing.filter((key) => !kits.has(key));
+  if (absent.length > 0)
+    return { notRun: missingSnapshots(graph, absent) };
+  if (libraries.length === 0)
+    return { notRun: "library/index.json is missing" };
+  const all = joinLibraries(libraries);
+  const joined = /* @__PURE__ */ new Map();
+  return {
+    all,
+    forTarget(targetId) {
+      const target = input2.config.targets.find((candidate) => candidate.id === targetId);
+      if (!target)
+        return all;
+      const cached2 = joined.get(targetId);
+      if (cached2)
+        return cached2;
+      const own2 = joinLibraries(snapshotsFor(input2, target).libraries);
+      joined.set(targetId, own2);
+      return own2;
+    }
+  };
+}
+
 // packages/zaku/dist/lib/domain/checks/binding.js
 var PAINTS = ["fill", "stroke", "textColor", "glyph"];
 var SEMANTIC = /^(color|mode|radius)\//;
-var binding = ({ library }) => {
-  if (!library)
-    return { notRun: "library.json is missing" };
+var binding = (input2) => {
+  const libraries = checkLibraries(input2);
+  if ("notRun" in libraries)
+    return libraries;
+  const library = libraries.all;
   const findings = [];
   for (const component2 of library.components) {
     for (const variant of component2.variants) {
@@ -47428,8 +48397,9 @@ var frameCheck = ({ config: config2, outlines }) => {
   }
   return { findings };
 };
-var systemBars = ({ config: config2, outlines }) => {
+var systemBars = ({ config: config2, outlines, kits }) => {
   const families2 = new Map(config2.targets.map((target) => [target.id, target.family]));
+  const graph = designGraph(config2);
   const bars = { ...DEFAULT_SYSTEM_BARS, ...config2.systemBars };
   const findings = [];
   for (const outline of outlines) {
@@ -47437,7 +48407,10 @@ var systemBars = ({ config: config2, outlines }) => {
       const family = families2.get(frame.target);
       if (!family)
         continue;
-      const held = new Set(frame.instances.map((instance) => instance.component));
+      const own2 = graph.kits.filter((kit) => kit.family === family && kits[kit.key]);
+      const kitKeys = new Set(own2.flatMap((kit) => kits[kit.key]?.components.map((component2) => component2.key) ?? []));
+      const from = own2.length > 0 ? ` from ${own2.map((kit) => kit.key).join(" or ")}` : "";
+      const held = new Set(frame.instances.filter((instance) => own2.length === 0 || kitKeys.has(instance.componentKey)).map((instance) => instance.component));
       for (const names of bars[family]) {
         if (!names.some((name) => held.has(name))) {
           findings.push({
@@ -47446,7 +48419,7 @@ var systemBars = ({ config: config2, outlines }) => {
             screen: outline.screen,
             frame: frame.name,
             nodeId: frame.nodeId,
-            message: `no ${names.join(" or ")} instance on a ${family} frame`
+            message: `no ${names.join(" or ")} instance${from} on a ${family} frame`
           });
         }
       }
@@ -47460,6 +48433,18 @@ var placement = ({ maps, outlines }) => {
   for (const outline of outlines) {
     const title = titles.get(`${outline.feature}/${outline.screen}`);
     for (const frame of outline.frames) {
+      if (frame.page !== void 0) {
+        if (title !== void 0 && frame.page !== title)
+          findings.push({
+            check: "placement",
+            feature: outline.feature,
+            screen: outline.screen,
+            frame: frame.name,
+            nodeId: frame.nodeId,
+            message: `sits on the page ${frame.page}, and its screen is drawn on the page ${title}`
+          });
+        continue;
+      }
       const expected = [title, frame.state];
       if (frame.containers.length !== 2 || frame.containers[0] !== expected[0] || frame.containers[1] !== expected[1]) {
         findings.push({
@@ -47493,8 +48478,19 @@ var naming = ({ outlines }) => {
   }
   return { findings };
 };
-var component = ({ outlines }) => {
+var component = ({ config: config2, outlines, productComponents }) => {
   const findings = [];
+  const graph = designGraph(config2);
+  for (const drawn of productComponents) {
+    const platform = graph.products.find((product) => product.key === drawn.source)?.platform;
+    const branches = new Set(config2.targets.filter((target) => graph.platformOf(target) === platform).flatMap((target) => graph.branchOf(target) ?? []));
+    const homes = graph.libraries.filter((library) => library.layer === "components" && library.branches.some((branch) => branches.has(branch))).map((library) => library.key);
+    findings.push({
+      check: "component",
+      nodeId: drawn.nodeId,
+      message: `${drawn.name} is a component on the product page ${drawn.page}; a product file draws screens only, so draw it in ${homes.length > 0 ? homes.join(" or ") : `a Components library of the ${[...branches].join(" or ")} branch`}`
+    });
+  }
   for (const outline of outlines) {
     const seen = /* @__PURE__ */ new Map();
     for (const frame of outline.frames) {
@@ -47526,13 +48522,16 @@ var component = ({ outlines }) => {
 };
 
 // packages/zaku/dist/lib/domain/checks/font.js
-var font = ({ outlines, library }) => {
-  if (!library)
-    return { notRun: "library.json is missing" };
-  const keys = new Set(library.textStyles.map((style) => style.key));
+var font = (input2) => {
+  const libraries = checkLibraries(input2);
+  if ("notRun" in libraries)
+    return libraries;
+  const keys = /* @__PURE__ */ new Map();
   const findings = [];
-  for (const outline of outlines) {
+  for (const outline of input2.outlines) {
     for (const frame of outline.frames) {
+      const styles = keys.get(frame.target) ?? new Set(libraries.forTarget(frame.target).textStyles.map((style) => style.key));
+      keys.set(frame.target, styles);
       const where = { feature: outline.feature, screen: outline.screen, frame: frame.name };
       for (const text of frame.texts) {
         if (text.styleKey === null) {
@@ -47542,7 +48541,7 @@ var font = ({ outlines, library }) => {
             nodeId: text.nodeId,
             message: "text outside a component uses no library text style"
           });
-        } else if (!keys.has(text.styleKey)) {
+        } else if (!styles.has(text.styleKey)) {
           findings.push({
             check: "font",
             ...where,
@@ -47557,8 +48556,9 @@ var font = ({ outlines, library }) => {
 };
 
 // packages/zaku/dist/lib/domain/checks/freshness.js
-var freshness = ({ maps, outlines, library }) => {
+var freshness = ({ config: config2, maps, outlines, flows, libraries }) => {
   const digests = new Map(maps.map((loaded) => [loaded.map.feature, loaded.digest]));
+  const graph = designGraph(config2);
   const findings = [];
   for (const outline of outlines) {
     const where = { feature: outline.feature, screen: outline.screen };
@@ -47570,11 +48570,35 @@ var freshness = ({ maps, outlines, library }) => {
         message: "the map changed after this outline was read; run zaku outline"
       });
     }
-    if (library && outline.libraryVersion !== library.version) {
+    for (const [key, library] of Object.entries(libraries)) {
+      const read = outline.libraryVersions[key] ?? (graph.legacy ? outline.libraryVersions[LEGACY_LIBRARY_VERSION] : void 0);
+      if (read === library.version)
+        continue;
       findings.push({
         check: "freshness",
         ...where,
-        message: "the library changed after this outline was read; run zaku outline"
+        message: graph.legacy ? "the library changed after this outline was read; run zaku outline" : `library ${key} changed after this outline was read; run zaku outline`
+      });
+    }
+  }
+  const drawn = new Map(outlines.flatMap((outline) => outline.frames.map((frame) => [`${outline.feature}/${outline.screen}
+${frame.name}`, frame])));
+  for (const page of flows) {
+    for (const copy2 of page.frames) {
+      if (copy2.screen === null)
+        continue;
+      const source = drawn.get(`${copy2.screen}
+${copy2.name}`);
+      if (source?.digest === void 0 || source.digest === copy2.digest)
+        continue;
+      const [feature = "", screen = ""] = copy2.screen.split("/");
+      findings.push({
+        check: "freshness",
+        feature,
+        screen,
+        frame: copy2.name,
+        nodeId: copy2.nodeId,
+        message: `the copy on the flow page ${page.page} differs from the frame it copies; copy it again`
       });
     }
   }
@@ -47582,13 +48606,43 @@ var freshness = ({ maps, outlines, library }) => {
 };
 
 // packages/zaku/dist/lib/domain/checks/library.js
-var libraryCheck = ({ config: config2, maps, outlines, library }) => {
-  if (!library)
-    return { notRun: "library.json is missing" };
+function frameFindings(input2) {
+  const libraries = checkLibraries(input2);
+  if ("notRun" in libraries)
+    return libraries;
+  const { config: config2, maps, outlines } = input2;
+  const library = libraries.all;
   const bars = systemBarNames(config2);
   const owned = outlines.flatMap((outline) => outline.frames.flatMap((frame) => frame.instances.filter((instance) => instance.local).map((instance) => instance.component)));
   const names = /* @__PURE__ */ new Set([...library.components.map((component2) => component2.name), ...owned]);
   const keys = new Set(library.components.flatMap((component2) => component2.variants.map((variant) => variant.key)));
+  const graph = designGraph(config2);
+  const owners = /* @__PURE__ */ new Map();
+  for (const [key, snapshot] of Object.entries(input2.libraries)) {
+    const holds = graph.libraries.find((candidate) => candidate.key === key)?.branches ?? [];
+    for (const component2 of snapshot.components) {
+      const branches = component2.branch ? [component2.branch] : holds;
+      for (const variant of component2.variants)
+        owners.set(variant.key, `${key}, a ${branches.join(" and ")} library`);
+    }
+  }
+  for (const [key, kit] of Object.entries(input2.kits)) {
+    for (const component2 of kit.components)
+      owners.set(component2.key, `${key}, an ${kit.family} kit`);
+  }
+  const allowed2 = /* @__PURE__ */ new Map();
+  const allowedFor = (target) => {
+    const cached2 = allowed2.get(target.id);
+    if (cached2)
+      return cached2;
+    const { libraries: own2, kits } = snapshotsFor(input2, target);
+    const set2 = /* @__PURE__ */ new Set([
+      ...own2.flatMap((snapshot) => snapshot.components.flatMap((component2) => component2.variants.map((v) => v.key))),
+      ...kits.flatMap((kit) => kit.components.map((component2) => component2.key))
+    ]);
+    allowed2.set(target.id, set2);
+    return set2;
+  };
   const findings = [];
   for (const { map: map2 } of maps) {
     for (const [id2, screen] of Object.entries(map2.screens)) {
@@ -47608,8 +48662,22 @@ var libraryCheck = ({ config: config2, maps, outlines, library }) => {
   for (const outline of outlines) {
     for (const frame of outline.frames) {
       const where = { feature: outline.feature, screen: outline.screen, frame: frame.name };
+      const target = config2.targets.find((candidate) => candidate.id === frame.target);
       for (const instance of frame.instances) {
-        if (!instance.local && !bars.has(instance.component) && !keys.has(instance.componentKey)) {
+        if (instance.local)
+          continue;
+        const owner = owners.get(instance.componentKey);
+        if (target && owner && !allowedFor(target).has(instance.componentKey)) {
+          const draws = owner.endsWith(" kit") ? `${target.family} kits` : graph.branchOf(target) ?? "no branch";
+          findings.push({
+            check: "library",
+            ...where,
+            nodeId: instance.nodeId,
+            message: `an instance of ${instance.component} comes from ${owner}; a ${target.name} frame draws from ${draws}`
+          });
+          continue;
+        }
+        if (!bars.has(instance.component) && !keys.has(instance.componentKey) && !owner) {
           findings.push({
             check: "library",
             ...where,
@@ -47629,6 +48697,82 @@ var libraryCheck = ({ config: config2, maps, outlines, library }) => {
     }
   }
   return { findings };
+}
+function referable(snapshot) {
+  return {
+    variable: Object.values(snapshot.variableKeys ?? {}).flatMap((variable) => variable.local ? [variable.key] : []),
+    "text style": snapshot.textStyles.map((style) => style.key),
+    "effect style": (snapshot.effectStyles ?? []).map((style) => style.key),
+    instance: snapshot.components.flatMap((component2) => [
+      component2.key,
+      ...component2.variants.map((variant) => variant.key)
+    ])
+  };
+}
+function referenceFindings(input2) {
+  const graph = designGraph(input2.config);
+  const findings = [];
+  for (const [key, snapshot] of Object.entries(input2.libraries)) {
+    if (!snapshot.variableKeys)
+      continue;
+    const bases = graph.closure(key).slice(1);
+    const missing = bases.filter((base) => !input2.libraries[base] && !input2.kits[base]);
+    if (missing.length > 0) {
+      const paths = missing.map((base) => graph.kits.some((kit) => kit.key === base) ? `library/${base}/kit.json` : `library/${base}/index.json`);
+      return { notRun: `${paths.join(", ")} ${paths.length === 1 ? "is" : "are"} missing` };
+    }
+    const allowed2 = {
+      variable: /* @__PURE__ */ new Set(),
+      "text style": /* @__PURE__ */ new Set(),
+      "effect style": /* @__PURE__ */ new Set(),
+      instance: new Set(snapshot.localComponents ?? [])
+    };
+    for (const from of [key, ...bases]) {
+      const library = input2.libraries[from];
+      if (library)
+        for (const [kind, keys] of Object.entries(referable(library)))
+          for (const ref of keys)
+            allowed2[kind].add(ref);
+      for (const component2 of input2.kits[from]?.components ?? [])
+        allowed2.instance.add(component2.key);
+    }
+    const extended2 = bases.length > 0 ? `from ${bases.join(", ")}` : "from a library it extends, and it extends none";
+    for (const component2 of snapshot.components) {
+      for (const variant of component2.variants) {
+        for (const item of variant.modes[0]?.items ?? []) {
+          const refs = [
+            ...(item.variableIds ?? []).map((id2) => [
+              "variable",
+              snapshot.variableKeys?.[id2]?.key ?? id2
+            ]),
+            ...item.textStyleKey ? [["text style", item.textStyleKey]] : [],
+            ...item.effectStyleKey ? [["effect style", item.effectStyleKey]] : [],
+            ...item.componentKey ? [["instance", item.componentKey]] : []
+          ];
+          for (const [kind, ref] of refs) {
+            if (allowed2[kind].has(ref))
+              continue;
+            findings.push({
+              check: "library",
+              nodeId: item.nodeId,
+              field: "references",
+              message: `${key}: ${component2.name} ${variant.name} ${item.path || "(root)"}: ${kind} ${ref} is neither the library's own nor ${extended2}`
+            });
+          }
+        }
+      }
+    }
+  }
+  return { findings };
+}
+var libraryCheck = (input2) => {
+  const frames = frameFindings(input2);
+  if ("notRun" in frames)
+    return frames;
+  const references = referenceFindings(input2);
+  if ("notRun" in references)
+    return references;
+  return { findings: [...frames.findings, ...references.findings] };
 };
 
 // packages/zaku/dist/lib/domain/checks/navigation.js
@@ -47699,7 +48843,11 @@ var ALLOWED_OVERRIDES = /* @__PURE__ */ new Set([
   "name",
   "componentProperties",
   "componentPropertyReferences",
-  "exposedInstances"
+  "exposedInstances",
+  "reactions",
+  "transitionNodeID",
+  "transitionDuration",
+  "transitionEasing"
 ]);
 var SIZING_MODES = /* @__PURE__ */ new Set(["primaryAxisSizingMode", "counterAxisSizingMode"]);
 function componentSized(field, size2, main2) {
@@ -47713,9 +48861,12 @@ function stretches(sizing) {
 function insideSwap(instance, nodeId) {
   return instance.nested.some((nested) => nodeId.startsWith(`${nested.nodeId};`) && instance.swaps.includes(nested.componentKey));
 }
-var overrides = ({ outlines, library }) => {
-  if (!library)
-    return { notRun: "library.json is missing" };
+var overrides = (input2) => {
+  const libraries = checkLibraries(input2);
+  if ("notRun" in libraries)
+    return libraries;
+  const { outlines } = input2;
+  const library = libraries.all;
   const nestedOf = /* @__PURE__ */ new Map();
   const componentOf = /* @__PURE__ */ new Map();
   for (const component2 of library.components) {
@@ -47776,18 +48927,58 @@ var overrides = ({ outlines, library }) => {
   return { findings };
 };
 
+// packages/zaku/dist/lib/domain/flows.js
+function flowsOf(maps) {
+  const index = indexScreens(maps);
+  const flows = [];
+  for (const root of index.values()) {
+    if (!root.screen.root)
+      continue;
+    const screens = [root];
+    for (let at = 0; at < screens.length; at += 1) {
+      const from = screens[at];
+      if (!from)
+        continue;
+      for (const exit of from.screen.exits) {
+        const next = index.get(qualify(exit.to, from.feature));
+        if (next && !screens.includes(next))
+          screens.push(next);
+      }
+    }
+    flows.push({ root, screens });
+  }
+  return flows;
+}
+
 // packages/zaku/dist/lib/domain/checks/prototype.js
-var prototype = ({ maps, outlines }) => {
-  if (outlines.length === 0)
-    return { findings: [] };
+function legacyScreens(input2) {
+  if (input2.flows.length === 0)
+    return input2.outlines;
+  const byScreen = /* @__PURE__ */ new Map();
+  for (const page of input2.flows) {
+    for (const frame of page.frames) {
+      if (frame.screen === null)
+        continue;
+      const [feature = "", screen = ""] = frame.screen.split("/");
+      const entry = byScreen.get(frame.screen) ?? { feature, screen, frames: [] };
+      entry.frames.push(frame);
+      byScreen.set(frame.screen, entry);
+    }
+  }
+  return [...byScreen.values()];
+}
+function legacyFindings(input2) {
+  const screens = legacyScreens(input2);
+  if (screens.length === 0)
+    return [];
   const screenOfFrame = /* @__PURE__ */ new Map();
-  const outlineOf = new Map(outlines.map((outline) => [`${outline.feature}/${outline.screen}`, outline]));
-  for (const outline of outlines) {
+  const outlineOf = new Map(screens.map((outline) => [`${outline.feature}/${outline.screen}`, outline]));
+  for (const outline of screens) {
     for (const frame of outline.frames)
       screenOfFrame.set(frame.nodeId, `${outline.feature}/${outline.screen}`);
   }
   const findings = [];
-  for (const { map: map2 } of maps) {
+  for (const { map: map2 } of input2.maps) {
     for (const [id2, screen] of Object.entries(map2.screens)) {
       const outline = outlineOf.get(`${map2.feature}/${id2}`);
       if (!outline)
@@ -47824,8 +49015,64 @@ var prototype = ({ maps, outlines }) => {
       }
     }
   }
-  return { findings };
-};
+  return findings;
+}
+function flowFindings(input2) {
+  const prototypes = new Set(designGraph(input2.config).prototypes.map((file2) => file2.key));
+  const findings = [];
+  for (const flow of flowsOf(input2.maps)) {
+    const { root } = flow;
+    const title = root.screen.title;
+    const keyOf = (ref) => `${ref.feature}/${ref.id}`;
+    const pages = input2.flows.filter((page) => page.page === title && prototypes.has(page.source));
+    if (pages.length === 0) {
+      findings.push({
+        check: "prototype",
+        feature: root.feature,
+        screen: root.id,
+        message: `no flow page is named ${title}`
+      });
+      continue;
+    }
+    const inFlow = new Set(flow.screens.map(keyOf));
+    for (const page of pages) {
+      const screenOf = new Map(page.frames.map((frame) => [frame.nodeId, frame.screen]));
+      const first = root.screen.states[0];
+      if (!page.frames.some((frame) => frame.screen === keyOf(root) && frame.state === first && frame.start))
+        findings.push({
+          check: "prototype",
+          feature: root.feature,
+          screen: root.id,
+          message: `the flow page ${title} does not start on ${title}'s first state`
+        });
+      for (const ref of flow.screens) {
+        const where = { check: "prototype", feature: ref.feature, screen: ref.id };
+        const copies = page.frames.filter((frame) => frame.screen === keyOf(ref));
+        for (const exit of ref.screen.exits) {
+          const target = qualify(exit.to, ref.feature);
+          if (!inFlow.has(target))
+            continue;
+          const connected = copies.some((frame) => frame.links.some((link) => link.to !== "back" && screenOf.get(link.to.nodeId) === target));
+          if (!connected)
+            findings.push({
+              ...where,
+              field: "exits",
+              message: `on the flow page ${title}, the exit to ${exit.to} (${exit.via}) has no connection`
+            });
+        }
+        if (ref !== root && copies.length > 0 && !copies.some((frame) => frame.links.some((link) => link.to === "back")))
+          findings.push({
+            ...where,
+            message: `on the flow page ${title}, a screen that is not the root has no Back action`
+          });
+      }
+    }
+  }
+  return findings;
+}
+var prototype = (input2) => ({
+  findings: designGraph(input2.config).prototypes.length > 0 ? flowFindings(input2) : legacyFindings(input2)
+});
 
 // packages/zaku/dist/lib/domain/checks/recipe.js
 function propsLabel(props) {
@@ -47845,7 +49092,7 @@ var GENERIC = /* @__PURE__ */ new Set(["serif", "sans-serif", "monospace", "curs
 function families(stack) {
   return stack.split(",").map((family) => family.trim().replace(/^["']|["']$/g, "")).filter((family) => family !== "" && !GENERIC.has(family.toLowerCase()));
 }
-function colour(at, field, library, code) {
+function colour2(at, field, library, code) {
   const transparent = { r: 0, g: 0, b: 0, a: 0 };
   const drawn = library ?? transparent;
   const coded = code ?? transparent;
@@ -47874,12 +49121,12 @@ function size(at, field, library, code) {
 }
 function comparePart(at, part) {
   const { item } = at;
-  colour(at, "background", item.fill, part.background);
+  colour2(at, "background", item.fill, part.background);
   if (item.type.toUpperCase() === "TEXT")
-    colour(at, "color", item.textColor, part.color);
-  colour(at, "borderColor", item.stroke, part.borderColor);
+    colour2(at, "color", item.textColor, part.color);
+  colour2(at, "borderColor", item.stroke, part.borderColor);
   if (item.glyph)
-    colour(at, "glyph", item.glyph, part.color);
+    colour2(at, "glyph", item.glyph, part.color);
   if (item.path === "") {
     if (!at.fallback)
       size(at, "width", item.width, part.width);
@@ -47905,9 +49152,14 @@ function comparePart(at, part) {
     });
   }
 }
-var recipe = ({ config: config2, library, recipe: doc }) => {
-  if (!doc || !library)
-    return { notRun: "recipe.json or library.json is missing" };
+var recipe = (input2) => {
+  const { config: config2, recipe: doc } = input2;
+  const libraries = checkLibraries(input2);
+  if ("notRun" in libraries)
+    return doc ? libraries : { notRun: `recipe.json or ${libraries.notRun}` };
+  if (!doc)
+    return { notRun: "recipe.json is missing" };
+  const library = libraries.all;
   const findings = [];
   for (const code of doc.components) {
     const component2 = library.components.find((candidate) => candidate.name === code.name);
@@ -47998,9 +49250,12 @@ var MIN_TARGET = {
 function controlsOf(frame) {
   return frame.instances.flatMap((instance) => [instance, ...instance.nested].flatMap((control) => control.interactive && control.bounds ? [{ nodeId: control.nodeId, componentKey: control.componentKey, bounds: control.bounds }] : []));
 }
-var targetSize = ({ config: config2, outlines, library }) => {
-  if (!library)
-    return { notRun: "library.json is missing" };
+var targetSize = (input2) => {
+  const libraries = checkLibraries(input2);
+  if ("notRun" in libraries)
+    return libraries;
+  const { config: config2, outlines } = input2;
+  const library = libraries.all;
   const presetHeight = /* @__PURE__ */ new Map();
   for (const component2 of library.components) {
     for (const variant of component2.variants) {
@@ -48082,9 +49337,14 @@ function rgbaOf(token) {
   const [r, g, b] = token.$value.components;
   return { r, g, b, a: token.$value.alpha };
 }
-var tokensCheck = ({ config: config2, library, tokens }) => {
-  if (!library || !tokens)
-    return { notRun: "library.json or tokens.json is missing" };
+var tokensCheck = (input2) => {
+  const { config: config2, tokens } = input2;
+  const libraries = checkLibraries(input2);
+  if ("notRun" in libraries)
+    return libraries;
+  if (!tokens)
+    return { notRun: "tokens.json is missing" };
+  const library = libraries.all;
   const sets = tokenSets(tokens);
   const findings = [];
   for (const [scheme, set2] of [
@@ -48388,13 +49648,25 @@ async function loadDesign(root) {
       message: `two screens share the title ${title}; a frame name could not tell them apart`
     });
   }
-  const { outlines, unmapped, errors: outlineErrors } = await loadOutlines(paths.outline);
+  const { outlines, flows, unmapped, errors: outlineErrors } = await loadOutlines(paths.outline);
   findings.push(...outlineErrors.map(schemaFinding));
-  const library = await optional3(() => readOptionalDesignFile(paths.library, librarySnapshotSchema), findings);
+  const { libraries, kits, errors: snapshotErrors } = await readDesignSnapshots(paths, config2);
+  findings.push(...snapshotErrors.map(schemaFinding));
   const tokens = await optional3(() => readOptionalDesignFile(paths.tokens, tokenDocumentSchema), findings);
   const recipe2 = await optional3(() => readOptionalDesignFile(paths.recipe, recipeDocumentSchema), findings);
   return {
-    input: { config: config2, maps, outlines, unmapped: unmapped?.frames ?? [], library, tokens, recipe: recipe2 },
+    input: {
+      config: config2,
+      maps,
+      outlines,
+      flows,
+      unmapped: unmapped?.frames ?? [],
+      productComponents: unmapped?.components ?? [],
+      libraries,
+      kits,
+      tokens,
+      recipe: recipe2
+    },
     findings
   };
 }
@@ -48429,6 +49701,7 @@ function refusalOf(error62) {
   }
   if (error62 instanceof FigmaFileKeyMissing) return { code: 3, line: error62.message };
   if (error62 instanceof FigmaTokenMissing) return { code: 3, line: error62.message };
+  if (error62 instanceof LibraryKeyMissing) return { code: 3, line: error62.message };
   if (error62 instanceof RecipePageFailed) return { code: 2, line: `zaku recipe: ${error62.message}` };
   return null;
 }
@@ -58116,35 +59389,35 @@ var StdioServerTransport = class {
 };
 
 // apps/zaku-cli/src/mcp/server.ts
-import { mkdir as mkdir4 } from "node:fs/promises";
+import { mkdir as mkdir5 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join11 } from "node:path";
 
 // apps/zaku-cli/src/mcp/screenshots.ts
-import { readdir as readdir3, rm as rm2, stat } from "node:fs/promises";
-import { join as join7 } from "node:path";
+import { readdir as readdir4, rm as rm3, stat } from "node:fs/promises";
+import { join as join9 } from "node:path";
 var KEPT_MS = 24 * 60 * 60 * 1e3;
 async function pruneScreenshots(dir, now) {
   let names;
   try {
-    names = await readdir3(dir);
+    names = await readdir4(dir);
   } catch {
     return;
   }
   for (const name of names.filter((entry) => entry.endsWith(".png"))) {
-    const path2 = join7(dir, name);
+    const path2 = join9(dir, name);
     const written = await stat(path2).then(
       (stats) => stats.mtimeMs,
       () => now
     );
-    if (now - written > KEPT_MS) await rm2(path2, { force: true });
+    if (now - written > KEPT_MS) await rm3(path2, { force: true });
   }
 }
 
 // apps/zaku-cli/src/mcp/tools.ts
 import { writeFile as writeFile5 } from "node:fs/promises";
-import { join as join8 } from "node:path";
-var fileKey = external_exports.string().min(1).regex(/^[0-9a-zA-Z]{22,128}$/).describe(
+import { join as join10 } from "node:path";
+var fileKey2 = external_exports.string().min(1).regex(/^[0-9a-zA-Z]{22,128}$/).describe(
   "The key of the Figma file to use. If the URL is provided, extract the file key from the URL: https://figma.com/design/:fileKey/:fileName."
 );
 var FALLBACK = "zaku's fallback for Figma's MCP server: the same tool and input, run in the file through the zaku plugin, which the person has open in that file with its key given.";
@@ -58156,7 +59429,7 @@ function registerFigmaTools(server, bridge, options) {
       inputSchema: external_exports.object({
         code: external_exports.string().max(5e4).describe("JavaScript code to execute. Has access to the `figma` global (Figma Plugin API)"),
         description: external_exports.string().max(2e3).describe("A concise description of what the code aims to do"),
-        fileKey,
+        fileKey: fileKey2,
         skillNames: external_exports.string().optional().describe("A comma-separated list of Figma skill names being followed, if any.")
       }).strict()
     },
@@ -58174,7 +59447,7 @@ function registerFigmaTools(server, bridge, options) {
       inputSchema: external_exports.object({
         contentsOnly: external_exports.boolean().optional().describe("When true, renders the node in isolation. Defaults to false."),
         enableBase64Response: external_exports.boolean().default(false).describe("When true, the response also includes the screenshot inline as a base64-encoded image entry."),
-        fileKey,
+        fileKey: fileKey2,
         maxDimension: external_exports.number().int().max(65536).default(1024).describe("Maximum pixel size of the longer edge of the rendered screenshot. Defaults to 1024."),
         nodeId: external_exports.string().min(1).regex(/^\d+[:-]\d+$/).describe('The ID of the node in the Figma document, eg. "123:456" or "123-456".')
       }).strict()
@@ -58187,7 +59460,7 @@ function registerFigmaTools(server, bridge, options) {
         options.timeoutMs
       );
       if (!answer.ok) return { isError: true, content: [{ type: "text", text: answer.error }] };
-      const path2 = join8(options.imageDir, `${id2.replace(":", "-")}-${Date.now()}.png`);
+      const path2 = join10(options.imageDir, `${id2.replace(":", "-")}-${Date.now()}.png`);
       await writeFile5(path2, Buffer.from(answer.png, "base64"));
       const text = JSON.stringify({
         path: path2,
@@ -58213,8 +59486,8 @@ async function serveMcp(log) {
   log(
     bridge.port === null ? "zaku mcp: no port from 7337 to 7346 was free; every call will say so" : `zaku mcp: listening for the zaku plugin on localhost:${bridge.port}`
   );
-  const imageDir = join9(tmpdir(), "zaku-screenshots");
-  await mkdir4(imageDir, { recursive: true });
+  const imageDir = join11(tmpdir(), "zaku-screenshots");
+  await mkdir5(imageDir, { recursive: true });
   await pruneScreenshots(imageDir, Date.now());
   const server = new McpServer({ name: "zaku", version: "1" });
   registerFigmaTools(server, bridge, { timeoutMs: CALL_TIMEOUT_MS, imageDir, log });
@@ -58230,7 +59503,7 @@ async function serveMcp(log) {
 
 // apps/zaku-cli/src/cli.ts
 var USE_FIGMA_CODE_LIMIT = 5e4;
-var USAGE = "usage: zaku <check|outline|tokens|recipe|library|rules|budget|schema|mcp> [--root docs/design]";
+var USAGE = "usage: zaku <check|outline|tokens|recipe|library|libraries|rules|budget|schema|mcp> [--root docs/design]";
 async function sendOrRefuse(cli, io, finish, command) {
   try {
     return await cli.bus.send(command);
@@ -58248,6 +59521,14 @@ async function recordRestCalls(cli, io) {
   const { seat, run } = seatAndRun(io.env);
   await cli.bus.send(new RecordBudgetCalls({ day: today(clock.now()), seat, run, kind: "rest", count }));
 }
+var librariesCommand = (program2, io, finish) => {
+  program2.command("libraries").description("print the design graph: what each target draws from, and what each file extends and is extended by").option("--root <dir>", "the design directory", "docs/design").action(async (options) => {
+    const paths = designPaths(resolve2(io.cwd, options.root));
+    const config2 = await readDesignFile(paths.config, zakuConfigSchema);
+    for (const line of printGraph(config2, await readDesignSnapshots(paths, config2))) io.out(line);
+    finish(0);
+  });
+};
 var schemaCommand = (program2, io, finish, cli) => {
   program2.command("schema").description("write the JSON Schemas an editor reads for the design files").option("--out <dir>", "where to write them", "docs/design").action(async (options) => {
     const written = await cli.bus.send(new WriteSchemas({ out: resolve2(io.cwd, options.out) }));
@@ -58260,7 +59541,7 @@ var checkCommand = (program2, io, finish) => {
     const loaded = await loadDesign(resolve2(io.cwd, options.root));
     const report = loaded.input ? runChecks(loaded.input, ALL_CHECKS) : { findings: [], notRun: [], passed: [] };
     report.findings.unshift(...loaded.findings);
-    const ran = options.input ? parseDesignFile(options.input, await readFile5(resolve2(io.cwd, options.input), "utf8"), rulesAnswerSchema) : null;
+    const ran = options.input ? parseDesignFile(options.input, await readFile6(resolve2(io.cwd, options.input), "utf8"), rulesAnswerSchema) : null;
     if (ran && "rulesError" in ran) {
       io.err(`zaku check: the rules did not run after the write: ${ran.rulesError}`);
       finish(1);
@@ -58274,7 +59555,7 @@ var checkCommand = (program2, io, finish) => {
   });
 };
 async function productPlaywright(cwd) {
-  const require2 = createRequire(join10(cwd, "package.json"));
+  const require2 = createRequire(join12(cwd, "package.json"));
   let resolved;
   try {
     resolved = require2.resolve("playwright");
@@ -58286,14 +59567,14 @@ async function productPlaywright(cwd) {
 }
 function fromProductTree(cwd, resolved) {
   for (let dir = resolve2(cwd); ; dir = dirname4(dir)) {
-    if (resolved.startsWith(join10(dir, "node_modules") + sep)) return true;
+    if (resolved.startsWith(join12(dir, "node_modules") + sep)) return true;
     if (dirname4(dir) === dir) return false;
   }
 }
 var runners = {
   run: execRun,
   loadPlaywright: productPlaywright,
-  rulesLibrary: () => readFile5(fileURLToPath(new URL("./rules.js", import.meta.url)), "utf8")
+  rulesLibrary: () => readFile6(fileURLToPath(new URL("./rules.js", import.meta.url)), "utf8")
 };
 var mcpCommand = (program2, io, finish) => {
   program2.command("mcp").description(
@@ -58411,13 +59692,26 @@ var libraryCommand = (program2, io, finish, cli) => {
       finish(0);
     }
   );
-  library.command("save").description("write library.json: the library components read over Figma REST, joined to the variables export").option("--root <dir>", "the design directory", "docs/design").option(
+  library.command("save").description(
+    "write a library's snapshot from its components over Figma REST, joined to the variables export, or a kit's published components"
+  ).option("--root <dir>", "the design directory", "docs/design").option("--key <key>", "the library or kit to save, as zaku.yaml lists it; needed when it lists several").option(
     "--input <variables.json>",
     "what use_figma returned for zaku library script; once per page export for a library in the product file",
     (value, previous = []) => [...previous, value]
   ).action(async (options) => {
     const root = resolve2(io.cwd, options.root);
-    if (!options.input || options.input.length === 0) {
+    const config2 = await readDesignFile(designPaths(root).config, zakuConfigSchema);
+    let target;
+    try {
+      target = librarySaveTarget(config2, options.key);
+    } catch (error62) {
+      const refusal = refusalOf(error62);
+      if (!refusal) throw error62;
+      io.err(refusal.line);
+      finish(refusal.code);
+      return;
+    }
+    if (target.kind === "library" && (!options.input || options.input.length === 0)) {
       io.err("zaku library save needs --input, the variables use_figma returned for zaku library script");
       finish(3);
       return;
@@ -58427,23 +59721,37 @@ var libraryCommand = (program2, io, finish, cli) => {
       finish(3);
       return;
     }
-    const part = mergeParts(
+    const part = target.kind === "library" ? mergeParts(
       await Promise.all(
-        options.input.map(
-          async (input2) => parseDesignFile(input2, await readFile5(resolve2(io.cwd, input2), "utf8"), variablePartSchema)
+        (options.input ?? []).map(
+          async (input2) => parseDesignFile(input2, await readFile6(resolve2(io.cwd, input2), "utf8"), variablePartSchema)
         )
       )
-    );
+    ) : void 0;
     try {
-      const snapshot = await cli.bus.send(new SaveLibrary({ root, part }));
+      const saved = await cli.bus.send(
+        new SaveLibrary({
+          root,
+          ...options.key !== void 0 ? { key: options.key } : {},
+          ...part ? { part } : {}
+        })
+      );
+      if (saved.kind === "kit") {
+        io.out(`wrote ${saved.dir}/kit.json: ${saved.kit.components.length} components`);
+        finish(0);
+        return;
+      }
+      const { snapshot, written, unchanged, removed } = saved;
       if (snapshot.components.length === 0) {
         io.err(
-          "library.json holds no components: the file publishes none and the export listed none; for a library in the product file, run zaku library script --local"
+          `${saved.dir}/ holds no components: the file publishes none and the export listed none; for a library in the product file, run zaku library script --local`
         );
         finish(1);
         return;
       }
-      io.out(`wrote library.json: ${snapshot.components.length} components at version ${snapshot.version}`);
+      io.out(
+        `wrote ${saved.dir}/: ${snapshot.components.length} components at version ${snapshot.version}; ${written.length} component files written, ${unchanged} unchanged, ${removed.length} removed`
+      );
       finish(0);
     } finally {
       await recordRestCalls(cli, io);
@@ -58452,7 +59760,7 @@ var libraryCommand = (program2, io, finish, cli) => {
 };
 var rulesCommand = (program2, io, finish) => {
   const rules = program2.command("rules").description("zaku's rule checks, for a run that reaches Figma through use_figma");
-  rules.command("script").description("print the Plugin API code that runs the rules over a page or a node, for use_figma").option("--root <dir>", "the design directory", "docs/design").option("--page <page>", "the page to check, by id or name").option("--node <id>", "the node to check, with everything inside it").option("--after <write.js>", "run this use_figma write first, then the rules, and answer both").action(async (options) => {
+  rules.command("script").description("print the Plugin API code that runs the rules over a page or a node, for use_figma").option("--root <dir>", "the design directory", "docs/design").option("--page <page>", "the page to check, by id or name").option("--node <id>", "the node to check, with everything inside it").option("--after <write.js>", "run this use_figma write first, then the rules, and answer both").option("--key <key>", "the library file the page is in, so its views are held to the branches it holds").action(async (options) => {
     if (options.page === void 0 === (options.node === void 0)) {
       io.err("zaku rules script needs --page or --node, one of them");
       finish(3);
@@ -58460,7 +59768,17 @@ var rulesCommand = (program2, io, finish) => {
     }
     const config2 = await readDesignFile(designPaths(resolve2(io.cwd, options.root)).config, zakuConfigSchema);
     const scope = options.node !== void 0 ? { nodeId: options.node } : { page: options.page };
-    const check2 = `await zakuRulesLib.zakuRules(figma, ${JSON.stringify({ scope, copy: resolveCopy(config2.copy) })})`;
+    const graph = designGraph(config2);
+    const file2 = options.key === void 0 ? graph.libraries.length === 1 ? graph.libraries[0] : void 0 : graph.libraries.find((library2) => library2.key === options.key);
+    if (options.key !== void 0 && !file2) {
+      io.err(
+        `zaku rules script: ${options.key} is not a library zaku.yaml lists; name one with --key: ${graph.libraries.map((library2) => library2.key).join(", ")}`
+      );
+      finish(3);
+      return;
+    }
+    const branches = file2?.branches ?? [];
+    const check2 = `await zakuRulesLib.zakuRules(figma, ${JSON.stringify({ scope, copy: resolveCopy(config2.copy), ...branches.length > 1 ? { branches } : {} })})`;
     const library = await runners.rulesLibrary();
     if (options.after === void 0) {
       io.out(`${library}
@@ -58468,11 +59786,11 @@ return ${check2};`);
       finish(0);
       return;
     }
-    const write = await readFile5(resolve2(io.cwd, options.after), "utf8");
+    const write2 = await readFile6(resolve2(io.cwd, options.after), "utf8");
     const body = [
       library,
       `const zakuWrite = async () => {
-${write}
+${write2}
 };`,
       "const zakuValue = await zakuWrite();",
       "const value = zakuValue === undefined ? null : zakuValue;",
@@ -58499,6 +59817,7 @@ var COMMANDS = [
   recipeCommand,
   budgetCommand,
   schemaCommand,
+  librariesCommand,
   mcpCommand
 ];
 async function main(argv, io) {