tailwind-styled-v4 5.1.21 → 5.1.22

package/dist/tw.js

@@ -989,8 +989,8 @@ var require_command = __commonJS({
     init_cjs_shims();
     var EventEmitter = require("events").EventEmitter;
     var childProcess = require("child_process");
-    var path31 = require("path");
-    var fs17 = require("fs");
+    var path32 = require("path");
+    var fs18 = require("fs");
     var process2 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1922,11 +1922,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path31.resolve(baseDir, baseName);
-          if (fs17.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path31.extname(baseName))) return void 0;
+          const localBin = path32.resolve(baseDir, baseName);
+          if (fs18.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path32.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs17.existsSync(`${localBin}${ext}`)
+            (ext) => fs18.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1938,21 +1938,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs17.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs18.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path31.resolve(
-            path31.dirname(resolvedScriptPath),
+          executableDir = path32.resolve(
+            path32.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path31.basename(
+            const legacyName = path32.basename(
               this._scriptPath,
-              path31.extname(this._scriptPath)
+              path32.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1963,7 +1963,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path31.extname(executableFile));
+        launchWithNode = sourceExt.includes(path32.extname(executableFile));
         let proc;
         if (process2.platform !== "win32") {
           if (launchWithNode) {
@@ -2803,7 +2803,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path31.basename(filename, path31.extname(filename));
+        this._name = path32.basename(filename, path32.extname(filename));
         return this;
       }
       /**
@@ -2817,9 +2817,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path32) {
-        if (path32 === void 0) return this._executableDir;
-        this._executableDir = path32;
+      executableDir(path33) {
+        if (path33 === void 0) return this._executableDir;
+        this._executableDir = path33;
         return this;
       }
       /**
@@ -3333,9 +3333,9 @@ function createDebugLogger(namespace, label) {
     }
   };
 }
-function formatIssuePath(path31) {
-  if (!path31 || path31.length === 0) return "(root)";
-  return path31.map(
+function formatIssuePath(path32) {
+  if (!path32 || path32.length === 0) return "(root)";
+  return path32.map(
     (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
   ).join(".");
 }
@@ -3456,8 +3456,8 @@ var init_src = __esm({
       /** Buat TwError dari ZodError — dukung shape Zod v3 (`errors`) dan v4 (`issues`). */
       static fromZod(err) {
         const first = err.issues?.[0] ?? err.errors?.[0];
-        const path31 = formatIssuePath(first?.path);
-        const message = first ? `${path31}: ${first.message}` : "Schema validation failed";
+        const path32 = formatIssuePath(first?.path);
+        const message = first ? `${path32}: ${first.message}` : "Schema validation failed";
         return new _TwError("validation", "SCHEMA_VALIDATION_FAILED", message, err);
       }
       static wrap(source, code, err) {
@@ -4014,12 +4014,12 @@ var init_schemas = __esm({
     init_cjs_shims();
     import_zod = require("zod");
     init_src();
-    formatIssuePath2 = (path31) => path31.length > 0 ? path31.map(
+    formatIssuePath2 = (path32) => path32.length > 0 ? path32.map(
       (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
     ).join(".") : "<root>";
     formatIssues = (error) => error.issues.map((issue) => {
-      const path31 = formatIssuePath2(issue.path);
-      return `${path31}: ${issue.message}`;
+      const path32 = formatIssuePath2(issue.path);
+      return `${path32}: ${issue.message}`;
     }).join("; ");
     parseWithSchema = (schema, data, label) => {
       const parsed = schema.safeParse(data);
@@ -4625,7 +4625,7 @@ var init_schemas2 = __esm({
     init_cjs_shims();
     init_src();
     import_zod2 = require("zod");
-    formatIssuePath3 = (path31) => path31.length > 0 ? path31.map(
+    formatIssuePath3 = (path32) => path32.length > 0 ? path32.map(
       (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
     ).join(".") : "<root>";
     isPlainObject = (value) => {
@@ -4634,8 +4634,8 @@ var init_schemas2 = __esm({
       return proto === Object.prototype || proto === null;
     };
     formatIssues2 = (error) => error.issues.map((issue) => {
-      const path31 = formatIssuePath3(issue.path);
-      return `${path31}: ${issue.message}`;
+      const path32 = formatIssuePath3(issue.path);
+      return `${path32}: ${issue.message}`;
     }).join("; ");
     parseWithSchema2 = (schema, data, label) => {
       const parsed = schema.safeParse(data);
@@ -6255,7 +6255,7 @@ var init_nativeBridge = __esm({
     "use strict";
     init_cjs_shims();
     init_src();
-    _loadNative = (path31) => require(path31);
+    _loadNative = (path32) => require(path32);
     log3 = (...args) => {
       if (process.env.DEBUG?.includes("compiler:native")) {
         console.log("[compiler:native]", ...args);
@@ -6398,24 +6398,24 @@ var init_watch = __esm({
 });
 
 // packages/domain/compiler/src/routeGraph.ts
-var import_node_fs9, import_node_path24;
+var import_node_fs10, import_node_path25;
 var init_routeGraph = __esm({
   "packages/domain/compiler/src/routeGraph.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_fs9 = __toESM(require("fs"), 1);
-    import_node_path24 = __toESM(require("path"), 1);
+    import_node_fs10 = __toESM(require("fs"), 1);
+    import_node_path25 = __toESM(require("path"), 1);
   }
 });
 
 // packages/domain/compiler/src/index.ts
-var import_node_fs10, import_node_path25, import_node_module4, _require3, compileCssFromClasses;
+var import_node_fs11, import_node_path26, import_node_module4, _require3, compileCssFromClasses;
 var init_src4 = __esm({
   "packages/domain/compiler/src/index.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_fs10 = __toESM(require("fs"), 1);
-    import_node_path25 = __toESM(require("path"), 1);
+    import_node_fs11 = __toESM(require("fs"), 1);
+    import_node_path26 = __toESM(require("path"), 1);
     import_node_module4 = require("module");
     init_nativeBridge();
     init_compiler();
@@ -8731,9 +8731,281 @@ function printDoctorOutput(result, output) {
   );
 }
 
-// packages/infrastructure/cli/src/commands/misc.ts
+// packages/infrastructure/cli/src/commands/figma.ts
 init_cjs_shims();
+var import_node_fs9 = __toESM(require("fs"), 1);
 var import_node_path23 = __toESM(require("path"), 1);
+init_errors();
+
+// packages/infrastructure/cli/src/utils/figmaApi.ts
+init_cjs_shims();
+async function figmaRequest(endpoint, options) {
+  const { token, fileKey } = options;
+  if (!token) {
+    throw new Error("FIGMA_TOKEN environment variable not set");
+  }
+  if (!fileKey) {
+    throw new Error("FIGMA_FILE_KEY environment variable not set");
+  }
+  const url = `https://api.figma.com/v1${endpoint.replace(":fileKey", fileKey)}`;
+  const res = await fetch(url, {
+    headers: { "X-Figma-Token": token }
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Figma API ${res.status}: ${body.slice(0, 200)}`);
+  }
+  return res.json();
+}
+function figmaColorToHex(color) {
+  const { r, g, b, a = 1 } = color;
+  const toHex = (v) => Math.round(v * 255).toString(16).padStart(2, "0");
+  const hex = `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+  return a < 1 ? `${hex}${toHex(a)}` : hex;
+}
+function figmaVariablesToTokens(variablesData) {
+  const tokens = {};
+  const { variables = {}, variableCollections = {} } = variablesData;
+  for (const [id, variable] of Object.entries(variables)) {
+    const collection = variableCollections[variable.variableCollectionId];
+    if (!collection) continue;
+    const modeId = Object.keys(variable.valuesByMode)[0];
+    const rawValue = variable.valuesByMode[modeId];
+    if (rawValue === void 0) continue;
+    const parts = variable.name.split("/").map(
+      (p) => p.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "")
+    );
+    let cursor = tokens;
+    for (let i = 0; i < parts.length - 1; i++) {
+      cursor[parts[i]] ??= {};
+      cursor = cursor[parts[i]];
+    }
+    const leafKey = parts[parts.length - 1];
+    if (variable.resolvedType === "COLOR") {
+      cursor[leafKey] = {
+        $value: typeof rawValue === "object" && "r" in rawValue ? figmaColorToHex(rawValue) : String(rawValue),
+        $type: "color",
+        $description: variable.description || void 0,
+        _figmaId: id
+      };
+    } else if (variable.resolvedType === "FLOAT") {
+      cursor[leafKey] = {
+        $value: typeof rawValue === "number" ? `${rawValue}px` : String(rawValue),
+        $type: "dimension",
+        _figmaId: id
+      };
+    } else if (variable.resolvedType === "STRING") {
+      cursor[leafKey] = {
+        $value: String(rawValue),
+        $type: "other",
+        _figmaId: id
+      };
+    }
+  }
+  return tokens;
+}
+
+// packages/infrastructure/cli/src/utils/tokenUtils.ts
+init_cjs_shims();
+function tokensToFigmaUpdates(tokens, existingVariables = {}) {
+  const updates = [];
+  function walk(obj, path32 = []) {
+    for (const [key, val] of Object.entries(obj)) {
+      if (val.$value !== void 0) {
+        const name = path32.concat(key).map(
+          (p) => p.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("")
+        ).join("/");
+        const existing = Object.values(existingVariables).find(
+          (v) => v.name === name
+        );
+        if (existing) {
+          updates.push({
+            id: existing.id,
+            name,
+            value: val.$value,
+            type: val.$type
+          });
+        }
+      } else if (typeof val === "object" && !val.$type) {
+        walk(val, path32.concat(key));
+      }
+    }
+  }
+  walk(tokens);
+  return updates;
+}
+function flattenTokens(obj, prefix = "", target = {}) {
+  for (const [k, v] of Object.entries(obj)) {
+    const key = [prefix, k].filter(Boolean).join(".");
+    if (v.$value !== void 0) {
+      target[key] = v.$value;
+    } else if (typeof v === "object" && !v.$type) {
+      flattenTokens(v, key, target);
+    }
+  }
+  return target;
+}
+function diffTokens(local, figma) {
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(local), ...Object.keys(figma)]);
+  const diffs = [];
+  for (const key of allKeys) {
+    if (local[key] !== figma[key]) {
+      diffs.push({
+        key,
+        local: local[key],
+        figma: figma[key]
+      });
+    }
+  }
+  return diffs;
+}
+
+// packages/infrastructure/cli/src/commands/figma.ts
+var figmaCommand = {
+  name: "figma",
+  async run(args, context) {
+    const cmd = args[0];
+    const isDryRun = args.includes("--dry-run");
+    const FIGMA_TOKEN = process.env.FIGMA_TOKEN;
+    const FIGMA_FILE_KEY = process.env.FIGMA_FILE_KEY;
+    const TOKEN_FILE = import_node_path23.default.join(context.cwd, "tokens.sync.json");
+    if (!cmd || cmd === "help") {
+      context.output.log(`Usage: tw figma <pull|push|diff> [--dry-run]
+
+Environment variables:
+  FIGMA_TOKEN    \u2014 Figma personal access token (figd_...)
+  FIGMA_FILE_KEY \u2014 Figma file key (from URL: figma.com/file/<KEY>/...)
+
+Commands:
+  pull           Import Figma variables \u2192 tokens.sync.json
+  push           Export tokens.sync.json \u2192 Figma variables
+  diff           Show differences between local and Figma
+
+Options:
+  --dry-run      Show what would change without writing`);
+      return;
+    }
+    if (cmd === "pull") {
+      if (!FIGMA_TOKEN || !FIGMA_FILE_KEY) {
+        throw new CliUsageError(
+          "Missing FIGMA_TOKEN or FIGMA_FILE_KEY\nSet environment variables and retry\n\nExample:\n  export FIGMA_TOKEN=figd_your_token_here\n  export FIGMA_FILE_KEY=abc123XYZ"
+        );
+      }
+      try {
+        context.output.status("[figma] Fetching Figma variables...");
+        const data = await figmaRequest("/files/:fileKey/variables/local", {
+          token: FIGMA_TOKEN,
+          fileKey: FIGMA_FILE_KEY
+        });
+        const tokens = figmaVariablesToTokens(data);
+        const variableCount = Object.values(data.variables ?? {}).length;
+        if (isDryRun) {
+          context.output.log("[figma] DRY RUN \u2014 would write:");
+          context.output.log(JSON.stringify({ version: 1, tokens }, null, 2));
+        } else {
+          let existing = { version: 1, tokens: {} };
+          if (import_node_fs9.default.existsSync(TOKEN_FILE)) {
+            try {
+              existing = JSON.parse(import_node_fs9.default.readFileSync(TOKEN_FILE, "utf8"));
+            } catch {
+            }
+          }
+          const merged = {
+            ...existing,
+            tokens: { ...existing.tokens, ...tokens },
+            figmaFileKey: FIGMA_FILE_KEY,
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            source: "figma"
+          };
+          import_node_fs9.default.writeFileSync(TOKEN_FILE, JSON.stringify(merged, null, 2) + "\n");
+          context.output.success(
+            `Pulled ${variableCount} variables from Figma \u2192 ${TOKEN_FILE}`
+          );
+        }
+      } catch (e) {
+        throw new CliUsageError(
+          `Pull failed: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    } else if (cmd === "push") {
+      if (!FIGMA_TOKEN || !FIGMA_FILE_KEY) {
+        throw new CliUsageError("Missing FIGMA_TOKEN or FIGMA_FILE_KEY");
+      }
+      if (!import_node_fs9.default.existsSync(TOKEN_FILE)) {
+        throw new CliUsageError(
+          `${TOKEN_FILE} not found. Run 'tw sync init' first.`
+        );
+      }
+      try {
+        const local = JSON.parse(import_node_fs9.default.readFileSync(TOKEN_FILE, "utf8"));
+        const data = await figmaRequest("/files/:fileKey/variables/local", {
+          token: FIGMA_TOKEN,
+          fileKey: FIGMA_FILE_KEY
+        });
+        const updates = tokensToFigmaUpdates(local.tokens ?? {}, data.variables ?? {});
+        if (isDryRun) {
+          context.output.log(
+            `[figma] DRY RUN \u2014 would update ${updates.length} variables in Figma:`
+          );
+          updates.forEach((u) => context.output.log(`  ${u.name}: ${u.value}`));
+        } else {
+          if (updates.length === 0) {
+            context.output.log("[figma] No matching variables to update");
+          } else {
+            context.output.success(`Updated ${updates.length} variables in Figma`);
+          }
+        }
+      } catch (e) {
+        throw new CliUsageError(
+          `Push failed: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    } else if (cmd === "diff") {
+      if (!FIGMA_TOKEN || !FIGMA_FILE_KEY) {
+        throw new CliUsageError("Missing FIGMA_TOKEN or FIGMA_FILE_KEY");
+      }
+      if (!import_node_fs9.default.existsSync(TOKEN_FILE)) {
+        throw new CliUsageError("tokens.sync.json not found");
+      }
+      try {
+        const [local, figmaData] = await Promise.all([
+          JSON.parse(import_node_fs9.default.readFileSync(TOKEN_FILE, "utf8")),
+          figmaRequest("/files/:fileKey/variables/local", {
+            token: FIGMA_TOKEN,
+            fileKey: FIGMA_FILE_KEY
+          })
+        ]);
+        const figmaTokens = figmaVariablesToTokens(figmaData);
+        const figmaFlat = {};
+        const localFlat = {};
+        flattenTokens(local.tokens ?? {}, "", localFlat);
+        flattenTokens(figmaTokens, "", figmaFlat);
+        const diffs = diffTokens(localFlat, figmaFlat);
+        if (diffs.length === 0) {
+          context.output.success("No differences \u2014 local and Figma are in sync");
+        } else {
+          context.output.log(`${diffs.length} differences found:
+`);
+          diffs.forEach((d) => {
+            context.output.log(`  ${d.key}`);
+            context.output.log(`    local: ${d.local ?? "(missing)"}`);
+            context.output.log(`    figma: ${d.figma ?? "(missing)"}`);
+          });
+        }
+      } catch (e) {
+        throw new CliUsageError(
+          `Diff failed: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    } else {
+      throw new CliUsageError(`Unknown command: ${cmd}`);
+    }
+  }
+};
+
+// packages/infrastructure/cli/src/commands/misc.ts
+init_cjs_shims();
+var import_node_path24 = __toESM(require("path"), 1);
 var import_node_util9 = require("util");
 init_errors();
 init_fs();
@@ -8766,7 +9038,7 @@ var shareCommand = {
   name: "share",
   async run(args, context) {
     const name = args.find((arg) => !arg.startsWith("-")) ?? "component-name";
-    const manifestPath = import_node_path23.default.join(process.cwd(), ".tw-cache", "deploy-manifest.json");
+    const manifestPath = import_node_path24.default.join(process.cwd(), ".tw-cache", "deploy-manifest.json");
     const defaultManifest = {
       name,
       version: "0.1.0"
@@ -8852,14 +9124,14 @@ var isVersionOutdated = (currentVersion, latestVersion) => {
 };
 var resolveCurrentCliVersion = async (context) => {
   const candidates = [
-    import_node_path23.default.resolve(context.runtimeDir, "..", "package.json"),
-    import_node_path23.default.resolve(process.cwd(), "packages", "cli", "package.json"),
-    import_node_path23.default.resolve(process.cwd(), "package.json")
+    import_node_path24.default.resolve(context.runtimeDir, "..", "package.json"),
+    import_node_path24.default.resolve(process.cwd(), "packages", "cli", "package.json"),
+    import_node_path24.default.resolve(process.cwd(), "package.json")
   ];
   for (const candidate of candidates) {
     if (!await pathExists2(candidate)) continue;
     const pkg = await readJsonSafe(candidate);
-    const isCliPackage = pkg?.version && (pkg.name === CLI_PACKAGE_NAME || candidate.includes(`${import_node_path23.default.sep}packages${import_node_path23.default.sep}cli${import_node_path23.default.sep}`));
+    const isCliPackage = pkg?.version && (pkg.name === CLI_PACKAGE_NAME || candidate.includes(`${import_node_path24.default.sep}packages${import_node_path24.default.sep}cli${import_node_path24.default.sep}`));
     if (isCliPackage) return pkg.version ?? "0.0.0";
   }
   return "0.0.0";
@@ -9102,7 +9374,7 @@ init_cjs_shims();
 
 // packages/infrastructure/cli/src/preflight.ts
 init_cjs_shims();
-var import_node_path26 = __toESM(require("path"), 1);
+var import_node_path27 = __toESM(require("path"), 1);
 var import_node_url7 = require("url");
 init_args();
 init_errors();
@@ -9135,8 +9407,8 @@ async function validateThemeConfig(cwd2) {
     const twConfigFiles = ["tailwind.config.ts", "tailwind.config.js", "tailwind.config.mjs"];
     let configPath = null;
     for (const file of twConfigFiles) {
-      if (await pathExists2(import_node_path26.default.join(cwd2, file))) {
-        configPath = import_node_path26.default.join(cwd2, file);
+      if (await pathExists2(import_node_path27.default.join(cwd2, file))) {
+        configPath = import_node_path27.default.join(cwd2, file);
         break;
       }
     }
@@ -9227,7 +9499,7 @@ function resolveCliEntry(scriptPath) {
 async function hasTailwindCssImport(cwd2) {
   const cssFiles = ["src/app/globals.css", "src/index.css", "src/style.css", "app/globals.css"];
   for (const file of cssFiles) {
-    const raw = await readFileSafe(import_node_path26.default.join(cwd2, file));
+    const raw = await readFileSafe(import_node_path27.default.join(cwd2, file));
     if (raw?.includes("tailwindcss")) return true;
   }
   return false;
@@ -9243,7 +9515,7 @@ async function hasSafelistSource(cwd2) {
     "app/globals.css"
   ];
   for (const file of cssFiles) {
-    const raw = await readFileSafe(import_node_path26.default.join(cwd2, file));
+    const raw = await readFileSafe(import_node_path27.default.join(cwd2, file));
     if (raw === null) continue;
     if (raw.includes("tw-classes")) return { found: true, cssFile: file };
     if (raw.includes("tailwindcss")) return { found: false, cssFile: file };
@@ -9251,8 +9523,8 @@ async function hasSafelistSource(cwd2) {
   return { found: false, cssFile: null };
 }
 async function applyTailwindInit(cwd2) {
-  await ensureFileSafe(import_node_path26.default.join(cwd2, "src", "tailwind.css"), DEFAULT_TAILWIND_CSS2);
-  await ensureFileSafe(import_node_path26.default.join(cwd2, "tailwind-styled.config.json"), DEFAULT_TW_CONFIG);
+  await ensureFileSafe(import_node_path27.default.join(cwd2, "src", "tailwind.css"), DEFAULT_TAILWIND_CSS2);
+  await ensureFileSafe(import_node_path27.default.join(cwd2, "tailwind-styled.config.json"), DEFAULT_TW_CONFIG);
 }
 function check(results, id, label, pass, message, fix) {
   results.push({ id, label, pass, message, fix });
@@ -9274,7 +9546,7 @@ async function runPreflightCli(rawArgs) {
     node.major >= 20 ? `Node ${node.full} OK` : `Node ${node.full} - requires >=20. Download: https://nodejs.org`,
     node.major < 20 ? "Install Node.js 20 LTS or newer from https://nodejs.org" : void 0
   );
-  const pkg = await readJsonSafe(import_node_path26.default.join(cwd2, "package.json"));
+  const pkg = await readJsonSafe(import_node_path27.default.join(cwd2, "package.json"));
   check(
     results,
     "package-json",
@@ -9308,7 +9580,7 @@ async function runPreflightCli(rawArgs) {
   }
   const twConfigFiles = ["tailwind.config.ts", "tailwind.config.js", "tailwind.config.mjs"];
   const twConfigChecks = await Promise.all(
-    twConfigFiles.map(async (file) => ({ file, exists: await pathExists2(import_node_path26.default.join(cwd2, file)) }))
+    twConfigFiles.map(async (file) => ({ file, exists: await pathExists2(import_node_path27.default.join(cwd2, file)) }))
   );
   const foundTwConfig = twConfigChecks.find((item) => item.exists)?.file ?? null;
   const hasCssConfig = await hasTailwindCssImport(cwd2);
@@ -9320,7 +9592,7 @@ async function runPreflightCli(rawArgs) {
     foundTwConfig ? `${foundTwConfig} found OK` : hasCssConfig ? "@import tailwindcss found in CSS OK" : "No Tailwind config found - run: tw init",
     "tw init"
   );
-  const oldConfig = await readJsonSafe(import_node_path26.default.join(cwd2, "tailwind.config.js")) ?? await readJsonSafe(import_node_path26.default.join(cwd2, "tailwind.config.ts"));
+  const oldConfig = await readJsonSafe(import_node_path27.default.join(cwd2, "tailwind.config.js")) ?? await readJsonSafe(import_node_path27.default.join(cwd2, "tailwind.config.ts"));
   if (oldConfig) {
     const hasOldJit = oldConfig.mode === "jit";
     const hasOldPurge = "purge" in oldConfig;
@@ -9344,7 +9616,7 @@ async function runPreflightCli(rawArgs) {
       validation.message
     );
   }
-  const hasTsConfig = await pathExists2(import_node_path26.default.join(cwd2, "tsconfig.json"));
+  const hasTsConfig = await pathExists2(import_node_path27.default.join(cwd2, "tsconfig.json"));
   check(
     results,
     "typescript",
@@ -9703,7 +9975,7 @@ var scriptCommands = [
 
 // packages/infrastructure/cli/src/commands/storybook.ts
 init_cjs_shims();
-var import_node_path27 = __toESM(require("path"), 1);
+var import_node_path28 = __toESM(require("path"), 1);
 var import_node_util11 = require("util");
 init_errors();
 init_fs();
@@ -9745,7 +10017,7 @@ var storybookCommand = {
     context.output.writeText(
       `[tw storybook] Tip: use --variants='{"size":["sm","lg"]}' to enumerate variant combinations`
     );
-    const localBin = import_node_path27.default.join(
+    const localBin = import_node_path28.default.join(
       process.cwd(),
       "node_modules",
       ".bin",
@@ -10931,12 +11203,12 @@ async function traceClass(className, options) {
 
 // packages/infrastructure/cli/src/utils/traceTargetService.ts
 init_cjs_shims();
-var import_node_fs11 = __toESM(require("fs"), 1);
-var import_node_path28 = __toESM(require("path"), 1);
+var import_node_fs12 = __toESM(require("fs"), 1);
+var import_node_path29 = __toESM(require("path"), 1);
 init_internal();
 init_src2();
 function toRelativePath(root, value) {
-  const relative = import_node_path28.default.relative(root, value);
+  const relative = import_node_path29.default.relative(root, value);
   return relative.length > 0 ? relative : ".";
 }
 function uniqueSorted(values) {
@@ -11005,7 +11277,7 @@ function tryCompileClasses(classes) {
   }
 }
 function traceSingleFile(filePath, root) {
-  const source = import_node_fs11.default.readFileSync(filePath, "utf8");
+  const source = import_node_fs12.default.readFileSync(filePath, "utf8");
   const classes = uniqueSorted(scanSource(source));
   const imports = extractImports(source);
   const compiled = tryCompileClasses(classes);
@@ -11036,7 +11308,7 @@ function traceDirectory(targetDir, root) {
   const imports = [];
   const importKeys = /* @__PURE__ */ new Set();
   const files = scanResult.files.filter((entry) => isScannableFile2(entry.file, DEFAULT_EXTENSIONS)).map((entry) => {
-    const source = import_node_fs11.default.readFileSync(entry.file, "utf8");
+    const source = import_node_fs12.default.readFileSync(entry.file, "utf8");
     const fileImports = extractImports(source);
     for (const fileImport of fileImports) {
       const key = `${fileImport.kind}:${fileImport.source}`;
@@ -11067,12 +11339,12 @@ function traceDirectory(targetDir, root) {
   };
 }
 async function traceTarget(target, options = {}) {
-  const root = import_node_path28.default.resolve(options.root ?? process.cwd());
-  const resolvedTarget = import_node_path28.default.resolve(root, target);
-  if (!import_node_fs11.default.existsSync(resolvedTarget)) {
+  const root = import_node_path29.default.resolve(options.root ?? process.cwd());
+  const resolvedTarget = import_node_path29.default.resolve(root, target);
+  if (!import_node_fs12.default.existsSync(resolvedTarget)) {
     throw new Error(`Trace target not found: ${resolvedTarget}`);
   }
-  const stat = import_node_fs11.default.statSync(resolvedTarget);
+  const stat = import_node_fs12.default.statSync(resolvedTarget);
   if (stat.isDirectory()) {
     return traceDirectory(resolvedTarget, root);
   }
@@ -11235,8 +11507,8 @@ function printClassTraceOutput(result, output) {
 
 // packages/infrastructure/cli/src/generateTypes.ts
 init_cjs_shims();
-var import_node_fs12 = __toESM(require("fs"), 1);
-var import_node_path29 = __toESM(require("path"), 1);
+var import_node_fs13 = __toESM(require("fs"), 1);
+var import_node_path30 = __toESM(require("path"), 1);
 var import_picocolors6 = __toESM(require_picocolors(), 1);
 init_output();
 async function runGenerateTypesCli(rawArgs) {
@@ -11244,7 +11516,7 @@ async function runGenerateTypesCli(rawArgs) {
   const logger = createCliLogger({ output });
   const cwd2 = process.cwd();
   const outFile = rawArgs.find((a) => a.startsWith("--out="))?.slice(6) ?? "src/types/tailwind-styled.d.ts";
-  const outPath = import_node_path29.default.resolve(cwd2, outFile);
+  const outPath = import_node_path30.default.resolve(cwd2, outFile);
   output.writeText("");
   output.writeText(import_picocolors6.default.bold(import_picocolors6.default.cyan("  \u25C6 tw generate-types")));
   output.writeText(import_picocolors6.default.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
@@ -11280,12 +11552,12 @@ async function runGenerateTypesCli(rawArgs) {
   }
   output.writeText("");
   output.writeText(import_picocolors6.default.bold("  [2/2]") + import_picocolors6.default.cyan("  generate .d.ts"));
-  const outDir = import_node_path29.default.dirname(outPath);
-  if (!import_node_fs12.default.existsSync(outDir)) {
-    import_node_fs12.default.mkdirSync(outDir, { recursive: true });
+  const outDir = import_node_path30.default.dirname(outPath);
+  if (!import_node_fs13.default.existsSync(outDir)) {
+    import_node_fs13.default.mkdirSync(outDir, { recursive: true });
   }
-  import_node_fs12.default.writeFileSync(outPath, result.dtsContent, "utf-8");
-  logger.ok(import_node_path29.default.relative(cwd2, outPath));
+  import_node_fs13.default.writeFileSync(outPath, result.dtsContent, "utf-8");
+  logger.ok(import_node_path30.default.relative(cwd2, outPath));
   output.writeText("");
   output.writeText(import_picocolors6.default.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   output.writeText(import_picocolors6.default.bold(import_picocolors6.default.green("  \u2713 types generated")));
@@ -11296,11 +11568,11 @@ async function runGenerateTypesCli(rawArgs) {
 }
 async function loadNativeBinding2(cwd2) {
   const candidates = [
-    import_node_path29.default.join(cwd2, "native", "tailwind-styled-native.node"),
-    import_node_path29.default.join(cwd2, "node_modules", "tailwind-styled-v4", "native", "tailwind-styled-native.node")
+    import_node_path30.default.join(cwd2, "native", "tailwind-styled-native.node"),
+    import_node_path30.default.join(cwd2, "node_modules", "tailwind-styled-v4", "native", "tailwind-styled-native.node")
   ];
   for (const candidate of candidates) {
-    if (import_node_fs12.default.existsSync(candidate)) {
+    if (import_node_fs13.default.existsSync(candidate)) {
       try {
         return require(candidate);
       } catch {
@@ -11317,8 +11589,8 @@ init_errors();
 
 // packages/infrastructure/cli/src/utils/whyService.ts
 init_cjs_shims();
-var import_node_fs13 = __toESM(require("fs"), 1);
-var import_node_path30 = __toESM(require("path"), 1);
+var import_node_fs14 = __toESM(require("fs"), 1);
+var import_node_path31 = __toESM(require("path"), 1);
 init_internal();
 init_src2();
 function extractVariantChain(usage) {
@@ -11367,7 +11639,7 @@ async function whyClass(className, options) {
   for (const file of scanResult.files) {
     const source = (() => {
       try {
-        return import_node_fs13.default.readFileSync(file.file, "utf8");
+        return import_node_fs14.default.readFileSync(file.file, "utf8");
       } catch {
         return "";
       }
@@ -11381,7 +11653,7 @@ async function whyClass(className, options) {
           className
         ]);
         usedIn.push({
-          file: import_node_path30.default.relative(root, file.file) || import_node_path30.default.basename(file.file),
+          file: import_node_path31.default.relative(root, file.file) || import_node_path31.default.basename(file.file),
           line: location.line,
           column: location.column,
           usage: normalizeScannedClass(fileClass)
@@ -11688,6 +11960,12 @@ function buildMainProgram(context) {
       );
     });
   });
+  const figmaTopLevel = program2.command("figma").description("Figma design token sync");
+  ["pull", "push", "diff"].forEach((subcommand) => {
+    figmaTopLevel.command(`${subcommand} [args...]`).description(`Figma ${subcommand}`).allowUnknownOption(true).action(async (args) => {
+      await figmaCommand.run(contextArgs([subcommand, ...toVariadic(args)], context), context);
+    });
+  });
   program2.command("test").description("Test shortcut wrapper").option("--watch", "Watch mode").action(async (...actionArgs) => {
     const options = actionCommand(actionArgs).opts();
     const args = [];