@design-twin/dtwin 0.1.0-alpha.0 → 0.1.1

package/layer/map-validate.js

@@ -0,0 +1,397 @@
+// GENERATED from design-to-code/ by claude-plugin/build-scripts.js — edit the source, then rebuild.
+
+
+// design-to-code/cli-args.ts
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// bridge/src/errmsg.ts
+var errMsg = (e) => typeof e === "string" ? e : String(e && e.message || e);
+
+// bridge/src/stdio.ts
+import { format, inspect } from "node:util";
+function installQueuedConsole(o = {}) {
+  trackWrites(process.stdout);
+  trackWrites(process.stderr);
+  const out = o.logTo === "stderr" ? process.stderr : process.stdout;
+  const err = process.stderr;
+  let indent = "";
+  const write = (s, text) => {
+    s.write((indent ? text.replace(/^/gm, indent) : text) + "\n");
+  };
+  const line = (s) => (...a) => {
+    write(s, format(...a));
+  };
+  console.log = console.info = console.debug = line(out);
+  console.warn = console.error = line(err);
+  console.dir = (item, options) => {
+    write(out, inspect(item, { customInspect: false, ...options }));
+  };
+  console.dirxml = line(out);
+  console.table = (data) => {
+    write(out, inspect(data));
+  };
+  console.write = (...data) => {
+    let n = 0;
+    for (const d of data) {
+      const b = typeof d === "string" ? Buffer.from(d) : d instanceof ArrayBuffer ? Buffer.from(d) : Buffer.from(d.buffer, d.byteOffset, d.byteLength);
+      if (b.length) {
+        out.write(b);
+        n += b.length;
+      }
+    }
+    return n;
+  };
+  console.clear = () => {
+    if (out.isTTY) out.write("\x1B[1;1H\x1B[0J");
+  };
+  console.trace = (...a) => {
+    const e = new Error(format(...a));
+    e.name = "Trace";
+    Error.captureStackTrace(e, console.trace);
+    write(err, e.stack ?? `Trace: ${e.message}`);
+  };
+  console.assert = (cond, ...a) => {
+    if (!cond) write(err, a.length ? "Assertion failed: " + format(...a) : "Assertion failed");
+  };
+  console.group = console.groupCollapsed = (...a) => {
+    if (a.length) write(out, format(...a));
+    indent += "  ";
+  };
+  console.groupEnd = () => {
+    indent = indent.slice(0, -2);
+  };
+  const counts = /* @__PURE__ */ new Map();
+  console.count = (label = "default") => {
+    const n = (counts.get(label) ?? 0) + 1;
+    counts.set(label, n);
+    write(out, `${label}: ${n}`);
+  };
+  console.countReset = (label = "default") => {
+    counts.delete(label);
+  };
+  const timers = /* @__PURE__ */ new Map();
+  const elapsed = (label) => {
+    const t = timers.get(label);
+    return t === void 0 ? null : `${label}: ${(performance.now() - t).toFixed(3)}ms`;
+  };
+  console.time = (label = "default") => {
+    timers.set(label, performance.now());
+  };
+  console.timeLog = (label = "default", ...a) => {
+    const e = elapsed(label);
+    if (e === null) write(err, `Warning: No such label '${label}' for console.timeLog()`);
+    else write(out, [e, ...a.map((x) => format(x))].join(" "));
+  };
+  console.timeEnd = (label = "default") => {
+    const e = elapsed(label);
+    timers.delete(label);
+    write(e === null ? err : out, e ?? `Warning: No such label '${label}' for console.timeEnd()`);
+  };
+}
+var inFlight = /* @__PURE__ */ new Map();
+function trackWrites(s) {
+  if (inFlight.has(s)) return;
+  const st = { n: 0, idle: [] };
+  inFlight.set(s, st);
+  const write = s.write.bind(s);
+  const settle = () => {
+    if (--st.n === 0) for (const r of st.idle.splice(0)) r();
+  };
+  s.write = (chunk, encoding, cb) => {
+    const done = typeof encoding === "function" ? encoding : cb;
+    const enc = typeof encoding === "function" ? void 0 : encoding;
+    if (chunk.length === 0) return write(chunk, enc, done);
+    st.n++;
+    let called = false;
+    return write(chunk, enc, (err) => {
+      if (!called) {
+        called = true;
+        settle();
+      }
+      done?.(err);
+    });
+  };
+}
+var CliExit = class extends Error {
+  code;
+  constructor(code) {
+    super(`exit ${code}`);
+    this.name = "CliExit";
+    this.code = code;
+  }
+};
+var cliDepth = 0;
+function exitCli(code) {
+  if (cliDepth > 0) throw new CliExit(code);
+  process.exit(code);
+}
+function runCli(main2, o, argv = process.argv.slice(2)) {
+  installQueuedConsole();
+  const done = o.done ?? ((code) => {
+    process.exitCode = code;
+  });
+  const fail = (e) => {
+    if (e instanceof CliExit) return done(e.code);
+    console.error(o.errorLine ? o.errorLine(e) : `${o.name}: ${e instanceof Error && e.stack || String(e)}`);
+    done(o.errorCode ?? 1);
+  };
+  cliDepth++;
+  let settled = false;
+  const leave = () => {
+    if (!settled) {
+      settled = true;
+      cliDepth--;
+    }
+  };
+  try {
+    const r = main2(argv);
+    if (typeof r === "number") {
+      leave();
+      done(r);
+    } else r.then((c) => {
+      leave();
+      done(c);
+    }, (e) => {
+      leave();
+      fail(e);
+    });
+  } catch (e) {
+    leave();
+    fail(e);
+  }
+}
+
+// design-to-code/proc.ts
+var pause = new Int32Array(new SharedArrayBuffer(4));
+
+// design-to-code/cli-args.ts
+var SELF = fileURLToPath(import.meta.url);
+var shellQuote = (p) => /["$`\\!]/.test(p) ? `'${p.replaceAll("'", `'\\''`)}'` : `"${p}"`;
+var SCRIPT_RUNNER = "bun --no-install --no-env-file";
+var scriptCmd = (name) => `${SCRIPT_RUNNER} ${shellQuote(path.join(path.dirname(SELF), name + path.extname(SELF)))}`;
+
+// bridge/src/read-json.ts
+import fs from "node:fs";
+var anyJson = (_x) => true;
+function readFailure(e) {
+  const code = e && typeof e === "object" && "code" in e ? e.code : void 0;
+  if (code === "ENOENT") return { error: "does not exist", missing: true };
+  return {
+    error: code === "EISDIR" ? "is a directory, not a file" : code === "EACCES" ? "is not readable (permission denied)" : `could not be read (${String(code || e)})`
+  };
+}
+function readJson(file, guard) {
+  let buf;
+  try {
+    buf = fs.readFileSync(file);
+  } catch (e) {
+    return readFailure(e);
+  }
+  if (buf.length >= 2 && (buf[0] === 255 && buf[1] === 254 || buf[0] === 254 && buf[1] === 255)) {
+    return { error: "is UTF-16, not UTF-8 \u2014 re-save it as UTF-8" };
+  }
+  let raw = buf.toString("utf8");
+  if (raw.charCodeAt(0) === 65279) raw = raw.slice(1);
+  let parsed;
+  try {
+    const value = JSON.parse(raw);
+    parsed = value;
+  } catch (e) {
+    return { error: `is not valid JSON \u2014 ${errMsg(e)}` };
+  }
+  if (!guard(parsed)) return { error: `is not ${guard.expected || "the expected kind of document"}` };
+  return { doc: parsed };
+}
+
+// design-to-code/catalog-input.ts
+function readJsonFile(file, what, hint) {
+  return readDocFile(file, what, anyJson, hint);
+}
+function readDocFile(file, what, guard, hint) {
+  return docOrExit(loadDocFile(file, what, guard, hint));
+}
+function loadDocFile(file, what, guard, hint, readAt = file) {
+  const r = readJson(readAt, guard);
+  if ("doc" in r) return r;
+  const ioFailure = r.missing || /^(is a directory|is not readable|could not be read)/.test(r.error);
+  return { error: `${what}: '${file}' ${r.error}${ioFailure ? "." : ""}` + (ioFailure && hint ? `
+       ${hint}` : "") };
+}
+function docOrExit(r) {
+  if ("doc" in r) return r.doc;
+  console.error(`error  ${r.error}`);
+  exitCli(2);
+}
+
+// bridge/src/json-util.ts
+function nullProto() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function isRecord(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+
+// design-to-code/map-validate-core.ts
+var STATUSES = ["active", "deprecated", "needs-review"];
+var KEYS = {
+  root: ["version", "figmaFileKey", "components"],
+  entry: ["figma", "code", "props", "variantOverrides", "childrenByLayer", "status", "note"],
+  figma: ["key", "id", "name", "unstable"],
+  code: ["module", "export", "targets"],
+  target: ["module", "export"],
+  vo: ["when", "code"],
+  voCode: ["module", "export"],
+  children: ["layerNamePattern", "slot"],
+  prop: Object.assign(nullProto(), {
+    enum: ["kind", "codeProp", "values", "default", "omitDefault"],
+    boolean: ["kind", "codeProp", "default", "omitDefault"],
+    string: ["kind", "codeProp"],
+    instance: ["kind", "codeProp", "slot"]
+  })
+};
+var PROP_KINDS = Object.keys(KEYS.prop);
+var isStr = (v) => typeof v === "string";
+var isBool = (v) => typeof v === "boolean";
+var noExtra = (obj, allowed, at, err) => {
+  if (!Array.isArray(allowed)) return;
+  for (const k of Object.keys(obj)) if (!allowed.includes(k)) err(`${at}.${k}`, "unknown property (additionalProperties:false)");
+};
+var optStrings = (obj, keys, at, err) => {
+  for (const k of keys) if (obj[k] !== void 0 && !isStr(obj[k])) err(`${at}.${k}`, "must be a string");
+};
+function validateMap(map) {
+  const errors = [];
+  const err = (path2, message) => errors.push({ path: path2, message });
+  if (!isRecord(map)) return { ok: false, errors: [{ path: "", message: "map must be an object" }] };
+  noExtra(map, KEYS.root, "", err);
+  if (map.version !== 1) err("version", "must be 1");
+  if (map.figmaFileKey !== void 0 && !isStr(map.figmaFileKey)) err("figmaFileKey", "must be a string");
+  if (!isRecord(map.components)) {
+    err("components", "must be an object");
+    return { ok: false, errors };
+  }
+  for (const key of Object.keys(map.components)) {
+    const e = map.components[key];
+    const at = `components.${key}`;
+    if (!isRecord(e)) {
+      err(at, "entry must be an object");
+      continue;
+    }
+    noExtra(e, KEYS.entry, at, err);
+    if (!isRecord(e.figma)) err(`${at}.figma`, "required object");
+    else {
+      noExtra(e.figma, KEYS.figma, `${at}.figma`, err);
+      if (!isStr(e.figma.name)) err(`${at}.figma.name`, "required string");
+      optStrings(e.figma, ["key", "id"], `${at}.figma`, err);
+      if (e.figma.unstable !== void 0 && !isBool(e.figma.unstable)) err(`${at}.figma.unstable`, "must be a boolean");
+    }
+    if (!isRecord(e.code)) err(`${at}.code`, "required object");
+    else {
+      noExtra(e.code, KEYS.code, `${at}.code`, err);
+      if (!isStr(e.code.module)) err(`${at}.code.module`, "required string");
+      if (!isStr(e.code.export)) err(`${at}.code.export`, "required string");
+      if (e.code.targets !== void 0) {
+        if (!isRecord(e.code.targets)) err(`${at}.code.targets`, "must be an object");
+        else for (const t of Object.keys(e.code.targets)) {
+          const tv = e.code.targets[t], ta = `${at}.code.targets.${t}`;
+          if (!isRecord(tv)) err(ta, "must be an object");
+          else {
+            noExtra(tv, KEYS.target, ta, err);
+            optStrings(tv, ["module", "export"], ta, err);
+          }
+        }
+      }
+    }
+    if (e.status !== void 0 && (!isStr(e.status) || !STATUSES.includes(e.status))) err(`${at}.status`, `must be one of ${STATUSES.join("|")}`);
+    optStrings(e, ["note"], at, err);
+    if (e.props !== void 0) {
+      if (!isRecord(e.props)) err(`${at}.props`, "must be an object");
+      else for (const pn of Object.keys(e.props)) validateProp(e.props[pn], `${at}.props.${pn}`, err);
+    }
+    if (e.variantOverrides !== void 0) {
+      if (!Array.isArray(e.variantOverrides)) err(`${at}.variantOverrides`, "must be an array");
+      else e.variantOverrides.forEach((vo, i) => {
+        const va = `${at}.variantOverrides[${i}]`;
+        if (!isRecord(vo)) {
+          err(va, "must be an object");
+          return;
+        }
+        noExtra(vo, KEYS.vo, va, err);
+        if (!isRecord(vo.when)) err(`${va}.when`, "required object");
+        else for (const wk of Object.keys(vo.when)) if (!isStr(vo.when[wk])) err(`${va}.when.${wk}`, "value must be a string");
+        if (!isRecord(vo.code)) err(`${va}.code`, "required object");
+        else {
+          noExtra(vo.code, KEYS.voCode, `${va}.code`, err);
+          if (!isStr(vo.code.module)) err(`${va}.code.module`, "required string");
+          if (!isStr(vo.code.export)) err(`${va}.code.export`, "required string");
+        }
+      });
+    }
+    if (e.childrenByLayer !== void 0) {
+      if (!isRecord(e.childrenByLayer)) err(`${at}.childrenByLayer`, "must be an object");
+      else {
+        noExtra(e.childrenByLayer, KEYS.children, `${at}.childrenByLayer`, err);
+        optStrings(e.childrenByLayer, ["layerNamePattern", "slot"], `${at}.childrenByLayer`, err);
+      }
+    }
+  }
+  return { ok: errors.length === 0, errors };
+}
+function validateProp(p, at, err) {
+  if (!isRecord(p)) {
+    err(at, "prop must be an object");
+    return;
+  }
+  const allowed = typeof p.kind === "string" ? KEYS.prop[p.kind] : void 0;
+  if (!Array.isArray(allowed)) {
+    err(`${at}.kind`, `must be one of ${PROP_KINDS.join("|")}`);
+    return;
+  }
+  noExtra(p, allowed, at, err);
+  if (p.kind !== "instance" && !isStr(p.codeProp)) err(`${at}.codeProp`, "required string");
+  if (p.kind === "instance" && p.codeProp !== void 0 && !isStr(p.codeProp)) err(`${at}.codeProp`, "must be a string");
+  if (p.kind === "instance" && p.slot !== void 0 && !isStr(p.slot)) err(`${at}.slot`, "must be a string");
+  if (p.kind === "enum") {
+    if (p.values !== void 0 && !isRecord(p.values)) err(`${at}.values`, "must be an object (VARIANT option -> code value)");
+    else if (isRecord(p.values)) for (const k of Object.keys(p.values)) {
+      const t = typeof p.values[k];
+      if (p.values[k] !== null && !["string", "number", "boolean"].includes(t)) err(`${at}.values.${k}`, "value must be string|number|boolean|null");
+    }
+    if (p.default !== void 0 && !["string", "number", "boolean"].includes(typeof p.default)) err(`${at}.default`, "must be string|number|boolean");
+  }
+  if (p.kind === "boolean" && p.default !== void 0 && !isBool(p.default)) err(`${at}.default`, "must be a boolean");
+  if ((p.kind === "enum" || p.kind === "boolean") && p.omitDefault !== void 0 && !isBool(p.omitDefault)) err(`${at}.omitDefault`, "must be a boolean");
+}
+function isCodeConnectMap(x) {
+  return validateMap(x).ok;
+}
+isCodeConnectMap.expected = "a valid component map (the map-validate script lists what is wrong with it)";
+
+// design-to-code/map-validate.ts
+function main(argv) {
+  const file = argv[0];
+  const USAGE = `usage: ${scriptCmd("map-validate")} <map.json>`;
+  if (file === "--help" || file === "-h") {
+    console.log(USAGE);
+    return 0;
+  }
+  if (!file || file.startsWith("-")) {
+    console.error((file ? `map-validate: unknown flag ${file}
+` : "") + USAGE);
+    return 1;
+  }
+  const res = validateMap(readJsonFile(file, "component map"));
+  if (res.ok) {
+    console.log("map valid");
+    return 0;
+  }
+  res.errors.forEach((e) => console.error(`  ${e.path || "(root)"}: ${e.message}`));
+  console.error(`
+${res.errors.length} error(s)`);
+  return 1;
+}
+if (import.meta.main) runCli(main, { name: "map-validate" });
+export {
+  main
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@design-twin/dtwin",
-  "version": "0.1.0-alpha.0",
+  "version": "0.1.1",
   "description": "Design Twin bridge: local CLI + MCP server between Claude Code and the Design Twin Figma plugin. Reads a design on the free Figma plan, fully offline.",
   "license": "MIT",
   "author": "Mohamed Magdy Omar",
@@ -31,11 +31,15 @@
   },
   "files": [
     "src",
+    "layer",
+    "figma-plugin",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
     "typecheck": "tsc --noEmit",
+    "prepack": "bun --no-install --no-env-file pack.ts",
+    "postpack": "bun --no-install --no-env-file pack.ts --clean",
     "pull": "bun src/figma-pull.ts",
     "pull:selection": "bun src/figma-pull.ts design --selection",
     "mcp": "bun src/figma-mcp.ts"

package/src/commands.ts

@@ -170,6 +170,9 @@ export interface WhoamiReply {
   /** null when `figma.fileKey` is unavailable (not a private plugin) */
   fileKey: string | null;
   fileKeyAvailable: boolean;
+  /** Whether the designer has ticked "Allow edits" in the plugin window (edits.ts). Absent from a plugin
+   *  built before the opt-in existed — which applies every write it is sent. */
+  editsAllowed?: boolean;
 }
 
 /** One selected node (figma.currentPage.selection, summarised). */
@@ -285,13 +288,23 @@ export type ExportReply = FullExportReply | DesignSystemReply | ScreenReply | Sc
 export interface AppliedWrite {
   id?: string;
 }
-/** writes.ts applyWrites' reply: `ok: false` on a partial failure, with what was applied before it. */
+/** Why a whole batch was refused before any op ran — the one refusal a caller must hand to the PERSON at
+ *  the Figma window rather than fix itself. `edits-off`: the designer has not ticked "Allow edits"
+ *  (figma-plugin/src/edits.ts); nothing in the file changed. */
+export type WriteRefusal = "edits-off";
+/** The sentence a refused `edits-off` batch carries as `error`, and what figma_write shows the agent. */
+export const EDITS_OFF_MESSAGE =
+  "Edits are off in the Design Twin plugin — tick 'Allow edits' in the plugin window, then retry. Nothing in the file was changed.";
+/** writes.ts applyWrites' reply: `ok: false` on a partial failure, with what was applied before it. A batch
+ *  refused whole carries `refused` (and no `failedAt`: no op was tried); one stopped partway because the designer
+ *  unticked "Allow edits" carries `refused` AND `failedAt`, with the applied prefix. */
 export interface WriteResult {
   ok: boolean;
   applied: AppliedWrite[];
   failedAt?: number;
   failedOp?: string;
   error?: string;
+  refused?: WriteRefusal;
 }
 
 // ---------------------------------------------------------------- the map

package/src/figma-mcp.ts

@@ -36,7 +36,7 @@ import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/proto
 import type { ServerNotification, ServerRequest } from "@modelcontextprotocol/sdk/types.js";
 // The command/reply contract shared with the plugin (commands.ts): every route request below is
 // typed per command from it, so a tool cannot read a reply field the plugin never sends.
-import { WRITE_OP_NAMES, writeOpPreview, type Cmd, type Commands, type ExportReply, type WriteOp } from "./commands.ts";
+import { EDITS_OFF_MESSAGE, WRITE_OP_NAMES, writeOpPreview, type Cmd, type Commands, type ExportReply, type WriteOp } from "./commands.ts";
 // TIMEOUTS is the per-command budget table shared with the dtwin CLI. Every EXPORT tool needs a
 // budget well above server-core's 120s default (tuned for ping/getSelection, not for a walk of every
 // node on a page) — a whole-file walk is the slow case, but a single big frame is the same shape of
@@ -681,7 +681,10 @@ const writeOpShape = z.object({
 }).passthrough();
 
 // Each step is commands.ts writeOpPreview — the op's WRITE_OPS row, which the plugin's wire check (writeOpError) reads too.
-function previewWrites(ops: WriteOp[]) {
+// `editsAllowed` is the plugin's "Allow edits" checkbox as its whoami reports it: false => a real write would be
+// refused (and `wouldRefuse` says what to ask the designer); null => unknown (no plugin reachable, or one built
+// before the opt-in).
+function previewWrites(ops: WriteOp[], editsAllowed: boolean | null) {
   const steps = ops.map(writeOpPreview);
   return {
     dryRun: true,
@@ -690,10 +693,30 @@ function previewWrites(ops: WriteOp[]) {
     overwrites: steps.filter((s) => s.effect === "overwrites").length,
     invalid: steps.filter((s) => "invalid" in s).length,
     steps,
-    note: "Nothing was changed. Overwrites cannot be undone from here (only Cmd-Z in Figma). Re-call without dryRun to apply.",
+    editsAllowed,
+    ...(editsAllowed === false ? { wouldRefuse: EDITS_OFF_MESSAGE } : {}),
+    note: "Nothing was changed. Overwrites cannot be undone from here (only Cmd-Z in Figma). " +
+      (editsAllowed === false
+        ? "A real write would be REFUSED right now: 'Allow edits' is off in the Design Twin plugin window — ask the designer to tick it, then re-call without dryRun."
+        : editsAllowed === null
+          ? "Could not read the plugin's 'Allow edits' setting (no single plugin reachable); a real write is refused while it is off. Re-call without dryRun to apply."
+          : "Re-call without dryRun to apply."),
   };
 }
 
+// The dry run's read of the "Allow edits" checkbox. Never waits for a plugin to connect (the preview must answer
+// with none): nothing connected, several connected with no `client` named, or any failure, is `null` (unknown).
+async function readEditsAllowed(a: { client?: string | undefined } | undefined): Promise<boolean | null> {
+  try {
+    const n = (await route.listClients()).length;
+    if (n === 0 || (!(a && a.client) && n > 1)) return null;
+    const who = await ask("whoami", {}, { timeoutMs: TIMEOUTS.command, target: a && a.client });
+    return typeof who.editsAllowed === "boolean" ? who.editsAllowed : null;
+  } catch {
+    return null;
+  }
+}
+
 server.registerTool(
   "figma_write",
   {
@@ -705,7 +728,10 @@ server.registerTool(
       "Ops are applied in order and are NOT transactional: if one fails, the earlier ones stay applied " +
       "and their node ids are reported alongside the error so you can continue or clean up. " +
       "There is no undo from here (only the designer's own Cmd-Z) — so for anything that OVERWRITES " +
-      "(setFill/setText), call once with dryRun:true, show the user the preview, and only then apply.",
+      "(setFill/setText), call once with dryRun:true, show the user the preview, and only then apply. " +
+      "The plugin applies nothing unless the designer has ticked 'Allow edits' in its window (off by default); " +
+      "while it is off a write is refused with that instruction, and a dry run reports editsAllowed:false — " +
+      "ask the designer to tick it, then retry.",
     inputSchema: {
       ...clientShape,
       // Constrain `op` to the four ops the plugin actually implements — reject unknown ops at the
@@ -715,7 +741,7 @@ server.registerTool(
         // 50 ops is several screens' worth of frames/text, and a larger job is simply several calls.
         .max(50, "at most 50 ops per call — split a larger job into several calls (writes cannot be undone from here)")
         .describe("Ordered list of write operations (each must have an `op` field). At most 50 per call."),
-      dryRun: z.boolean().optional().describe("true = validate the batch and return a preview of what each op would create/overwrite, WITHOUT touching the Figma file (needs no plugin connection)."),
+      dryRun: z.boolean().optional().describe("true = validate the batch and return a preview of what each op would create/overwrite, WITHOUT touching the Figma file (needs no plugin connection; when one is connected it also reports editsAllowed — false means a real write would be refused)."),
     },
     // destructiveHint MUST stay true. Per the MCP schema it asserts, when false, that "the tool
     // performs only additive updates" — but setFill/setText OVERWRITE properties on nodes the user
@@ -728,10 +754,13 @@ server.registerTool(
   guarded(async (a) => {
     // The preview is built HERE, not plugin-side: it must work before a connection exists, and the
     // annotations above are only a hint — not every MCP client turns destructiveHint into a prompt.
-    if (a.dryRun) return textResult(previewWrites(a.ops || []));
+    if (a.dryRun) return textResult(previewWrites(a.ops || [], await readEditsAllowed(a)));
     // No cancel signal here (unlike the reads): a write cannot be un-applied, and aborting the wait would
     // only lose the `applied` ids below.
     const r = await ask("write", { ops: a.ops || [] }, { target: a && a.client });
+    // The designer has not consented: nothing was tried, so there is no op index and nothing to clean up. The
+    // fix is the PERSON's (a checkbox in the plugin window), so say exactly that rather than "write failed".
+    if (r.refused === "edits-off" && !r.applied.length) return errorResult(r.error || EDITS_OFF_MESSAGE);
     // Partial failure is reported as an error result, but MUST still carry `applied` — those nodes
     // exist in the document and the agent needs their ids to continue or undo.
     if (!r.ok) {
@@ -752,14 +781,16 @@ server.registerTool(
 // — without these the agent has the figma_* tools and no way in, and the map and the codegen skill drift
 // into two different formats. Registering them here is what makes that layer exist for its actual
 // consumer.
-// Loaded LAZILY, on call, and never at module scope. ../../design-to-code/ is a SIBLING of this package
-// root (bridge/), so npm — whose `files` cannot reach outside the package root — does not ship it.
-// Importing it eagerly would take the whole server down with a module-not-found on a `bun add -g @design-twin/dtwin`
-// install, killing the other twelve tools over two that merely cannot work. So the server always
-// starts and only these two report, precisely, that they need the repo checkout.
+// Loaded LAZILY, on call, and never at module scope, from one of two places. In a repo checkout it is
+// ../../design-to-code/<mod>.ts, a SIBLING of this package root (bridge/) — which npm's `files` cannot reach. So
+// the npm package carries the layer as bundles instead: `prepack` (bridge/pack.ts) copies the committed,
+// self-contained claude-plugin/scripts/<mod>.js into ../layer/. Neither there (a checkout without design-to-code/,
+// a package packed without its prepack): importing eagerly would take the whole server down with a
+// module-not-found, killing the other tools over two that merely cannot work — so the server always starts and only
+// these two report, precisely, what is missing.
 // The slice of each layer module this server calls, declared HERE (over doc-types.ts shapes) rather
 // than as `typeof import("../../design-to-code/x.ts")`: even a type-only reference pulls that file and
-// its imports into the bridge program, and the published package (src/ alone) would then name files it
+// its imports into the bridge program, and the published package (src/ is TypeScript, the layer only bundles) would name files it
 // does not ship (see doc-types.ts). So bridge/src has no dependency of any kind on the layer — only the
 // dynamic import below, which fails soft. Mirrors design-to-code/get-component.ts GetComponentResult and
 // design-to-code/drift-lint.ts runDriftLint(); keep them in step (test/mcp-smoke.test.ts checks the real modules still satisfy these at compile time).
@@ -775,27 +806,27 @@ export interface DriftLintModule {
     | { status: "linted"; errors: unknown[]; warnings: unknown[]; freshness: unknown; summary: unknown; catalogs: ReadonlyArray<{ file: string }>; coverage: { coverage: object; warnings: unknown[] } | null };
 }
 async function loadLayer<T>(mod: string, tool: string): Promise<T> {
-  // The layer sits beside bridge/ in a repo checkout and nowhere in the npm package. Whether it is there
+  // The source in a checkout first (what the repo's tests run), else the package's bundle. Whether either is there
   // is asked of the file system, before the import: the import's own failure cannot say it — a missing
   // dependency OF the layer fails the same way, and the error's code and url fields differ between
   // runtimes (Bun reports neither the way Node did). Any error from an import of a file that IS there
   // is passed on as it is.
-  const url = new URL("../../design-to-code/" + mod, import.meta.url);
-  if (!fs.existsSync(url)) {
+  const url = [new URL(`../../design-to-code/${mod}.ts`, import.meta.url), new URL(`../layer/${mod}.js`, import.meta.url)].find((u) => fs.existsSync(u));
+  if (!url) {
     throw new Error(
-      `${tool} needs the design-to-code layer, which is not present in this install. It ships with the ` +
-        `Design Twin repository, not with the published npm package — run this MCP server from a repo ` +
-        `checkout (bun bridge/src/figma-mcp.ts) to use it. Everything else on this server works either way.`
+      `${tool} needs the design-to-code layer, which is not present in this install: neither a repo checkout's ` +
+        `design-to-code/${mod}.ts nor the npm package's layer/${mod}.js. Reinstall @design-twin/dtwin, or run this MCP ` +
+        `server from a repo checkout (bun bridge/src/figma-mcp.ts). Everything else on this server works either way.`
     );
   }
   return (await import(url.href)) as T;
 }
 const getComponent = async (catalogFile: string, handle: string) =>
-  (await loadLayer<GetComponentModule>("get-component.ts", "design_get_component")).getComponent(
+  (await loadLayer<GetComponentModule>("get-component", "design_get_component")).getComponent(
     catalogFile,
     handle
   );
-const driftLintLayer = () => loadLayer<DriftLintModule>("drift-lint.ts", "design_drift_lint");
+const driftLintLayer = () => loadLayer<DriftLintModule>("drift-lint", "design_drift_lint");
 
 // The export's component catalog is export-reader.ts readComponentCatalog's: the `files.componentsLocal` pointer
 // (inside the export only), else an older export's inline components[] in design-system.json — the catalog `dtwin

package/src/figma-pull.ts

@@ -947,6 +947,11 @@ async function whoamiCmd({ route, send, finish }: Session): Promise<void> {
   console.error("[dtwin] plugin version: " + (r.pluginVersion || "unknown (older bundle — predates version reporting)"));
   const stale = pluginStalenessNote(r.pluginVersion);
   if (stale) console.error("[dtwin] ! " + stale);
+  console.error("[dtwin] edits: " + (r.editsAllowed === true
+    ? "ALLOWED — the designer ticked 'Allow edits' in the plugin window; figma_write can change this file"
+    : r.editsAllowed === false
+      ? "off — the plugin refuses every write until the designer ticks 'Allow edits' in the plugin window (reads are unaffected)"
+      : "unknown (older bundle — predates the 'Allow edits' opt-in, and applies every write)"));
   console.error("[dtwin] fileKey: " + (r.fileKeyAvailable
     ? r.fileKey + " (available — usable as a stable routing key)"
     : "UNAVAILABLE (gated to private plugins; routing must use a server-minted id)"));