p1-polymorph-studio 0.1.0

package/dist/chunk-HGZJ53NR.cjs

@@ -0,0 +1,817 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/utils/errors.ts
+var LexApiError = class extends Error {
+  constructor(message, statusCode, body) {
+    super(message);
+    this.statusCode = statusCode;
+    this.body = body;
+    this.name = "LexApiError";
+  }
+};
+var LexValidationError = class extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "LexValidationError";
+  }
+};
+var LexConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LexConfigError";
+  }
+};
+
+// src/utils/api.ts
+function toSnakeCase(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function toCamelCase(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function convertKeys(obj, converter) {
+  if (obj === null || obj === void 0) return obj;
+  if (Array.isArray(obj)) return obj.map((item) => convertKeys(item, converter));
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[converter(key)] = convertKeys(value, converter);
+    }
+    return result;
+  }
+  return obj;
+}
+function toApiPayload(obj) {
+  return convertKeys(obj, toSnakeCase);
+}
+function fromApiResponse(obj) {
+  return convertKeys(obj, toCamelCase);
+}
+function createApiClient(options) {
+  const { baseUrl, token, projectId } = options;
+  const fetchFn = _nullishCoalesce(options.fetch, () => ( globalThis.fetch));
+  async function request(method, path, body, params) {
+    const url = new URL(path, baseUrl);
+    url.searchParams.set("project_id", projectId);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value);
+      }
+    }
+    const headers = {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json"
+    };
+    const init = { method, headers };
+    if (body !== void 0) {
+      init.body = JSON.stringify(toApiPayload(body));
+    }
+    const response = await fetchFn(url.toString(), init);
+    if (!response.ok) {
+      let errorBody;
+      try {
+        errorBody = await response.json();
+      } catch (e2) {
+        errorBody = await response.text();
+      }
+      throw new LexApiError(
+        `API request failed: ${method} ${path} \u2192 ${response.status}`,
+        response.status,
+        errorBody
+      );
+    }
+    if (response.status === 204) return void 0;
+    const data = await response.json();
+    return fromApiResponse(data);
+  }
+  return {
+    get: (path, params) => request("GET", path, void 0, params),
+    post: (path, body) => request("POST", path, body),
+    put: (path, body) => request("PUT", path, body),
+    del: (path) => request("DELETE", path)
+  };
+}
+
+// src/client/kuds.ts
+var _promises = require('fs/promises');
+
+// src/types/registry.ts
+var _zod = require('zod');
+
+// src/types/kud.ts
+
+var KUDFieldTypeSchema = _zod.z.enum([
+  "string",
+  "text",
+  "number",
+  "boolean",
+  "image",
+  "link",
+  "array",
+  "object"
+]);
+var KUDFieldDefSchema = _zod.z.lazy(
+  () => _zod.z.object({
+    type: KUDFieldTypeSchema,
+    required: _zod.z.boolean().optional(),
+    description: _zod.z.string().optional(),
+    items: KUDFieldDefSchema.optional(),
+    properties: _zod.z.record(_zod.z.string(), KUDFieldDefSchema).optional()
+  })
+);
+var KUDSchema = _zod.z.object({
+  id: _zod.z.string().uuid(),
+  projectId: _zod.z.string(),
+  type: _zod.z.string(),
+  label: _zod.z.string().nullable().optional(),
+  version: _zod.z.number().int().default(1),
+  schema: _zod.z.record(_zod.z.string(), KUDFieldDefSchema),
+  defaultKuiId: _zod.z.string().uuid().nullable().optional(),
+  metadata: _zod.z.record(_zod.z.string(), _zod.z.unknown()).nullable().optional(),
+  createdAt: _zod.z.string(),
+  updatedAt: _zod.z.string()
+});
+var CreateKUDInputSchema = _zod.z.object({
+  type: _zod.z.string().min(1),
+  label: _zod.z.string().optional(),
+  schema: _zod.z.record(_zod.z.string(), KUDFieldDefSchema),
+  metadata: _zod.z.record(_zod.z.string(), _zod.z.unknown()).optional()
+});
+var UpdateKUDInputSchema = _zod.z.object({
+  label: _zod.z.string().optional(),
+  schema: _zod.z.record(_zod.z.string(), KUDFieldDefSchema).optional(),
+  metadata: _zod.z.record(_zod.z.string(), _zod.z.unknown()).optional()
+});
+
+// src/types/registry.ts
+var KudRegistryEntrySchema = _zod.z.object({
+  type: _zod.z.string(),
+  label: _zod.z.string().optional(),
+  version: _zod.z.number().int().default(1),
+  schema: _zod.z.record(_zod.z.string(), KUDFieldDefSchema),
+  componentPath: _zod.z.string().optional(),
+  metadata: _zod.z.record(_zod.z.string(), _zod.z.unknown()).optional()
+});
+var KudRegistrySchema = _zod.z.object({
+  version: _zod.z.number().int().default(1),
+  projectId: _zod.z.string(),
+  generatedAt: _zod.z.string(),
+  kuds: _zod.z.array(KudRegistryEntrySchema)
+});
+
+// src/utils/diff.ts
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return false;
+  const aObj = a;
+  const bObj = b;
+  const aKeys = Object.keys(aObj);
+  const bKeys = Object.keys(bObj);
+  if (aKeys.length !== bKeys.length) return false;
+  return aKeys.every((key) => deepEqual(aObj[key], bObj[key]));
+}
+function diffRegistryVsDatabase(registry, dbKuds) {
+  const dbByType = new Map(dbKuds.map((kud) => [kud.type, kud]));
+  const registryTypes = new Set(registry.map((e) => e.type));
+  const toCreate = [];
+  const toUpdate = [];
+  const unchanged = [];
+  for (const entry of registry) {
+    const existing = dbByType.get(entry.type);
+    if (!existing) {
+      toCreate.push(entry);
+    } else if (!deepEqual(entry.schema, existing.schema)) {
+      toUpdate.push({ entry, existingId: existing.id });
+    } else {
+      unchanged.push(existing);
+    }
+  }
+  const toDelete = dbKuds.filter((kud) => !registryTypes.has(kud.type));
+  return { toCreate, toUpdate, toDelete, unchanged };
+}
+
+// src/client/kuds.ts
+function createKudsClient(api, projectId) {
+  return {
+    async list() {
+      return api.get("/kuds");
+    },
+    async getByType(type) {
+      const kuds = await api.get("/kuds", { type });
+      return _nullishCoalesce(kuds[0], () => ( null));
+    },
+    async create(input) {
+      return api.post("/kuds", input);
+    },
+    async update(id, input) {
+      return api.put(`/kuds/${id}`, input);
+    },
+    async delete(id) {
+      await api.del(`/kuds/${id}`);
+    },
+    async syncFromRegistry(registryPath) {
+      const raw = await _promises.readFile.call(void 0, registryPath, "utf-8");
+      const registry = KudRegistrySchema.parse(JSON.parse(raw));
+      const dbKuds = await api.get("/kuds");
+      const diff = diffRegistryVsDatabase(registry.kuds, dbKuds);
+      for (const entry of diff.toCreate) {
+        await api.post("/kuds", {
+          type: entry.type,
+          label: entry.label,
+          schema: entry.schema,
+          metadata: entry.metadata
+        });
+      }
+      for (const { entry, existingId } of diff.toUpdate) {
+        await api.put(`/kuds/${existingId}`, {
+          schema: entry.schema,
+          label: entry.label,
+          metadata: entry.metadata
+        });
+      }
+      for (const kud of diff.toDelete) {
+        await api.del(`/kuds/${kud.id}`);
+      }
+      return {
+        created: diff.toCreate.length,
+        updated: diff.toUpdate.length,
+        deleted: diff.toDelete.length,
+        unchanged: diff.unchanged.length
+      };
+    },
+    async syncToRegistry(registryPath) {
+      const dbKuds = await api.get("/kuds");
+      const registry = {
+        version: 1,
+        projectId,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        kuds: dbKuds.map((kud) => ({
+          type: kud.type,
+          label: _nullishCoalesce(kud.label, () => ( void 0)),
+          version: kud.version,
+          schema: kud.schema,
+          metadata: _nullishCoalesce(kud.metadata, () => ( void 0))
+        }))
+      };
+      await _promises.writeFile.call(void 0, registryPath, JSON.stringify(registry, null, 2) + "\n", "utf-8");
+    }
+  };
+}
+
+// src/utils/cosine.ts
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Vector length mismatch: ${a.length} vs ${b.length}`);
+  }
+  let dot = 0;
+  let magA = 0;
+  let magB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    magA += a[i] * a[i];
+    magB += b[i] * b[i];
+  }
+  const magnitude = Math.sqrt(magA) * Math.sqrt(magB);
+  if (magnitude === 0) return 0;
+  return dot / magnitude;
+}
+function blendedScore(candidatePosition, candidateVelocity, query) {
+  const positionScore = cosineSimilarity(candidatePosition, query.queryVector);
+  const weight = _nullishCoalesce(query.velocityWeight, () => ( 0.3));
+  if (!query.queryVelocity || !candidateVelocity || weight === 0) {
+    return { score: positionScore, positionScore, velocityScore: 0 };
+  }
+  const velocityScore = cosineSimilarity(candidateVelocity, query.queryVelocity);
+  const score = (1 - weight) * positionScore + weight * velocityScore;
+  return { score, positionScore, velocityScore };
+}
+
+// src/client/kuis.ts
+function createKuisClient(api, _projectId) {
+  return {
+    async list(filter) {
+      const params = {};
+      if (_optionalChain([filter, 'optionalAccess', _2 => _2.kudType])) params.kud_type = filter.kudType;
+      if (_optionalChain([filter, 'optionalAccess', _3 => _3.locale])) params.locale = filter.locale;
+      if (_optionalChain([filter, 'optionalAccess', _4 => _4.status])) params.status = filter.status;
+      if (_optionalChain([filter, 'optionalAccess', _5 => _5.intentStage])) params.intent_stage = filter.intentStage;
+      return api.get("/kuis", params);
+    },
+    async resolve(input) {
+      try {
+        return await api.post("/kuis/resolve", input);
+      } catch (err) {
+        if (err instanceof LexApiError && err.statusCode === 404) {
+          const kuis = await api.get("/kuis", {
+            kud_type: input.kudType,
+            locale: input.locale,
+            status: "published"
+          });
+          if (kuis.length === 0) return null;
+          let bestKui = null;
+          let bestScore = -Infinity;
+          for (const kui of kuis) {
+            const { score } = blendedScore(
+              kui.intentAffinity,
+              kui.intentVelocity,
+              {
+                queryVector: input.intentVector,
+                queryVelocity: input.intentVelocity,
+                velocityWeight: input.velocityWeight
+              }
+            );
+            if (score > bestScore || score === bestScore && kui.priority > (_nullishCoalesce(_optionalChain([bestKui, 'optionalAccess', _6 => _6.priority]), () => ( 0)))) {
+              bestScore = score;
+              bestKui = kui;
+            }
+          }
+          return bestKui;
+        }
+        throw err;
+      }
+    },
+    async create(input) {
+      return api.post("/kuis", input);
+    },
+    async update(id, input) {
+      return api.put(`/kuis/${id}`, input);
+    },
+    async publish(id) {
+      return api.put(`/kuis/${id}`, { status: "published" });
+    },
+    async archive(id) {
+      return api.put(`/kuis/${id}`, { status: "archived" });
+    },
+    async bulkImport(items) {
+      let created = 0;
+      const errors = [];
+      for (let i = 0; i < items.length; i++) {
+        try {
+          await api.post("/kuis", items[i]);
+          created++;
+        } catch (err) {
+          errors.push({
+            index: i,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+      return { created, errors };
+    }
+  };
+}
+
+// src/client/layouts.ts
+function createLayoutsClient(api, _projectId) {
+  return {
+    async get(pageId, locale) {
+      const params = {};
+      if (locale) params.locale = locale;
+      return api.get(`/layouts/${pageId}`, params);
+    },
+    async update(pageId, locale, input) {
+      return api.put(`/layouts/${pageId}`, { locale, ...input });
+    },
+    async resolve(pageId, opts) {
+      try {
+        return await api.post(`/layouts/${pageId}/resolve`, {
+          locale: _nullishCoalesce(opts.locale, () => ( "en")),
+          intentVector: opts.intentVector,
+          intentVelocity: opts.intentVelocity,
+          velocityWeight: opts.velocityWeight
+        });
+      } catch (err) {
+        if (err instanceof LexApiError && err.statusCode === 404) {
+          const locale = _nullishCoalesce(opts.locale, () => ( "en"));
+          const layout = await this.get(pageId, locale);
+          const resolvedSlots = await Promise.all(
+            layout.slots.map(async (slot) => {
+              const kuis = await api.get("/kuis", {
+                kud_type: slot.kudId,
+                locale,
+                status: "published"
+              });
+              let bestKui = null;
+              let bestScore = -Infinity;
+              for (const kui of kuis) {
+                const { score } = blendedScore(
+                  kui.intentAffinity,
+                  kui.intentVelocity,
+                  {
+                    queryVector: opts.intentVector,
+                    queryVelocity: opts.intentVelocity,
+                    velocityWeight: opts.velocityWeight
+                  }
+                );
+                if (score > bestScore || score === bestScore && kui.priority > (_nullishCoalesce(_optionalChain([bestKui, 'optionalAccess', _7 => _7.priority]), () => ( 0)))) {
+                  bestScore = score;
+                  bestKui = kui;
+                }
+              }
+              return {
+                slotId: slot.slotId,
+                kui: bestKui,
+                score: bestScore
+              };
+            })
+          );
+          return {
+            pageId,
+            slots: resolvedSlots.filter((s) => s.kui !== null)
+          };
+        }
+        throw err;
+      }
+    }
+  };
+}
+
+// src/client/tokens.ts
+
+
+// src/utils/css-parser.ts
+function classifyToken(name) {
+  if (name.startsWith("--color-") || name.startsWith("--tw-color-")) return "colors";
+  if (name.startsWith("--font-") || name.startsWith("--tw-font-")) return "typography";
+  if (name.startsWith("--spacing-") || name.startsWith("--tw-spacing-")) return "spacing";
+  if (name.startsWith("--radius-") || name.startsWith("--tw-radius-")) return "borderRadius";
+  if (name.startsWith("--shadow-") || name.startsWith("--tw-shadow-")) return "shadows";
+  return "other";
+}
+function stripPrefix(name) {
+  return name.replace(/^--(?:tw-)?/, "");
+}
+function extractTokensFromCSS(cssContent) {
+  const tokens = [];
+  const rootBlockRegex = /:root\s*\{([^}]+)\}/g;
+  let match;
+  while ((match = rootBlockRegex.exec(cssContent)) !== null) {
+    const block = match[1];
+    parseCustomProperties(block, tokens);
+  }
+  const themeBlockRegex = /@theme\s*\{([^}]+)\}/g;
+  while ((match = themeBlockRegex.exec(cssContent)) !== null) {
+    const block = match[1];
+    parseCustomProperties(block, tokens);
+  }
+  return tokens;
+}
+function parseCustomProperties(block, tokens) {
+  const propRegex = /(--[\w-]+)\s*:\s*([^;]+);/g;
+  let match;
+  while ((match = propRegex.exec(block)) !== null) {
+    const name = match[1];
+    const value = match[2].trim();
+    tokens.push({
+      collection: classifyToken(name),
+      name: stripPrefix(name),
+      value
+    });
+  }
+}
+function generateCSSFromTokens(tokens) {
+  const lines = [":root {"];
+  for (const token of tokens) {
+    const cssName = `--${token.name}`;
+    const value = _nullishCoalesce(token.valueLight, () => ( token.valueDark));
+    if (value !== null && value !== void 0) {
+      lines.push(`  ${cssName}: ${String(value)};`);
+    }
+  }
+  lines.push("}");
+  const darkTokens = tokens.filter((t) => t.valueDark !== null && t.valueDark !== void 0);
+  if (darkTokens.length > 0) {
+    lines.push("");
+    lines.push("@media (prefers-color-scheme: dark) {");
+    lines.push("  :root {");
+    for (const token of darkTokens) {
+      lines.push(`    --${token.name}: ${String(token.valueDark)};`);
+    }
+    lines.push("  }");
+    lines.push("}");
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/client/tokens.ts
+function createTokensClient(api, _projectId) {
+  return {
+    async pushFromCode(cssPath) {
+      const css = await _promises.readFile.call(void 0, cssPath, "utf-8");
+      const extracted = extractTokensFromCSS(css);
+      let upserted = 0;
+      for (const token of extracted) {
+        await api.post("/tokens", {
+          collection: token.collection,
+          name: token.name,
+          valueLight: token.value
+        });
+        upserted++;
+      }
+      return { upserted };
+    },
+    async pullToCode(cssPath) {
+      const tokens = await api.get("/tokens");
+      const css = generateCSSFromTokens(tokens);
+      await _promises.writeFile.call(void 0, cssPath, css, "utf-8");
+    },
+    async pullFromFigma(opts) {
+      const url = `https://api.figma.com/v1/files/${opts.fileKey}/variables/local`;
+      const response = await fetch(url, {
+        headers: { "X-Figma-Token": opts.figmaToken }
+      });
+      if (!response.ok) {
+        throw new Error(`Figma API error: ${response.status} ${response.statusText}`);
+      }
+      const data = await response.json();
+      let synced = 0;
+      const variables = Object.values(data.meta.variables);
+      for (const variable of variables) {
+        const collection = variable.resolvedType.toLowerCase() === "color" ? "colors" : "other";
+        const modes = Object.entries(variable.valuesByMode);
+        const lightValue = _optionalChain([modes, 'access', _8 => _8[0], 'optionalAccess', _9 => _9[1]]);
+        const darkValue = _optionalChain([modes, 'access', _10 => _10[1], 'optionalAccess', _11 => _11[1]]);
+        await api.post("/tokens", {
+          collection,
+          name: variable.name,
+          valueLight: lightValue,
+          valueDark: darkValue,
+          figmaVariableId: variable.id
+        });
+        synced++;
+      }
+      return { synced };
+    },
+    async exportDTCG() {
+      const tokens = await api.get("/tokens");
+      const dtcg = {};
+      for (const token of tokens) {
+        const parts = token.name.split("/");
+        let current = dtcg;
+        for (let i = 0; i < parts.length - 1; i++) {
+          if (!current[parts[i]]) current[parts[i]] = {};
+          current = current[parts[i]];
+        }
+        const leafName = parts[parts.length - 1];
+        current[leafName] = {
+          $value: token.valueLight,
+          $type: token.collection === "colors" ? "color" : token.collection,
+          ...token.valueDark ? { $extensions: { "com.figma": { dark: token.valueDark } } } : {}
+        };
+      }
+      return dtcg;
+    }
+  };
+}
+
+// src/client/config.ts
+
+var _fs = require('fs');
+function createConfigClient(api, projectId) {
+  return {
+    async generate(outputPath = "314-lex.config.json") {
+      let existing = {};
+      try {
+        const raw = await _promises.readFile.call(void 0, outputPath, "utf-8");
+        existing = JSON.parse(raw);
+      } catch (e3) {
+      }
+      const config = {
+        $schema: "https://unpkg.com/@314-lex/sdk/schema/config.json",
+        version: 2,
+        name: _nullishCoalesce(existing.name, () => ( projectId)),
+        projectId: _nullishCoalesce(existing.projectId, () => ( projectId)),
+        tokens: existing.tokens,
+        kuds: existing.kuds,
+        figma: existing.figma,
+        api: _nullishCoalesce(existing.api, () => ( {
+          baseUrl: "env:POLYMORPH_BASE_URL",
+          token: "env:POLYMORPH_TOKEN",
+          routes: "/api/314-lex"
+        })),
+        github: existing.github
+      };
+      await _promises.writeFile.call(void 0, outputPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    },
+    async generateRegistry(outputPath = "kuds.registry.json") {
+      const dbKuds = await api.get("/kuds");
+      const registry = {
+        version: 1,
+        projectId,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        kuds: dbKuds.map((kud) => ({
+          type: kud.type,
+          label: _nullishCoalesce(kud.label, () => ( void 0)),
+          version: kud.version,
+          schema: kud.schema,
+          metadata: _nullishCoalesce(kud.metadata, () => ( void 0))
+        }))
+      };
+      await _promises.writeFile.call(void 0, outputPath, JSON.stringify(registry, null, 2) + "\n", "utf-8");
+    },
+    watch(opts) {
+      const watchers = [];
+      for (const path of opts.paths) {
+        const watcher = _fs.watch.call(void 0, path, { recursive: true }, (_event, filename) => {
+          if (filename) {
+            opts.onChange(filename);
+          }
+        });
+        watchers.push(watcher);
+      }
+      return () => {
+        for (const watcher of watchers) {
+          watcher.close();
+        }
+      };
+    }
+  };
+}
+
+// src/types/kui.ts
+
+var IntentVectorSchema = _zod.z.tuple([
+  _zod.z.number(),
+  _zod.z.number(),
+  _zod.z.number(),
+  _zod.z.number(),
+  _zod.z.number()
+]);
+var KUIStatusSchema = _zod.z.enum(["draft", "published", "archived"]);
+var KUISchema = _zod.z.object({
+  id: _zod.z.string().uuid(),
+  kudId: _zod.z.string().uuid(),
+  kudType: _zod.z.string(),
+  projectId: _zod.z.string(),
+  locale: _zod.z.string().default("en"),
+  intentAffinity: IntentVectorSchema,
+  intentVelocity: IntentVectorSchema.nullable().optional(),
+  priority: _zod.z.number().int().default(0),
+  content: _zod.z.record(_zod.z.string(), _zod.z.unknown()),
+  metadata: _zod.z.record(_zod.z.string(), _zod.z.unknown()).nullable().optional(),
+  status: KUIStatusSchema.default("draft"),
+  createdAt: _zod.z.string(),
+  updatedAt: _zod.z.string()
+});
+var CreateKUIInputSchema = _zod.z.object({
+  kudType: _zod.z.string().min(1),
+  locale: _zod.z.string().default("en"),
+  intentAffinity: IntentVectorSchema,
+  intentVelocity: IntentVectorSchema.optional(),
+  priority: _zod.z.number().int().default(0),
+  content: _zod.z.record(_zod.z.string(), _zod.z.unknown()),
+  metadata: _zod.z.record(_zod.z.string(), _zod.z.unknown()).optional()
+});
+var UpdateKUIInputSchema = _zod.z.object({
+  locale: _zod.z.string().optional(),
+  intentAffinity: IntentVectorSchema.optional(),
+  intentVelocity: IntentVectorSchema.nullable().optional(),
+  priority: _zod.z.number().int().optional(),
+  content: _zod.z.record(_zod.z.string(), _zod.z.unknown()).optional(),
+  metadata: _zod.z.record(_zod.z.string(), _zod.z.unknown()).optional(),
+  status: KUIStatusSchema.optional()
+});
+var ResolveKUIInputSchema = _zod.z.object({
+  kudType: _zod.z.string().min(1),
+  intentVector: IntentVectorSchema,
+  intentVelocity: IntentVectorSchema.optional(),
+  velocityWeight: _zod.z.number().min(0).max(1).default(0.3),
+  locale: _zod.z.string().default("en")
+});
+var ListKUIsFilterSchema = _zod.z.object({
+  kudType: _zod.z.string().optional(),
+  locale: _zod.z.string().optional(),
+  status: KUIStatusSchema.optional(),
+  intentStage: _zod.z.enum(["awareness", "interest", "consideration", "decision", "evaluation"]).optional()
+});
+
+// src/types/layout.ts
+
+var PageSlotSchema = _zod.z.object({
+  slotId: _zod.z.string(),
+  kudId: _zod.z.string(),
+  required: _zod.z.boolean().default(true),
+  candidateKuiIds: _zod.z.array(_zod.z.string()).optional()
+});
+var PageLayoutSchema = _zod.z.object({
+  id: _zod.z.string().uuid(),
+  projectId: _zod.z.string(),
+  pageId: _zod.z.string(),
+  locale: _zod.z.string().default("en"),
+  slots: _zod.z.array(PageSlotSchema),
+  createdAt: _zod.z.string(),
+  updatedAt: _zod.z.string()
+});
+var ResolvedSlotSchema = _zod.z.object({
+  slotId: _zod.z.string(),
+  kui: KUISchema,
+  score: _zod.z.number()
+});
+var ResolvedPageSchema = _zod.z.object({
+  pageId: _zod.z.string(),
+  slots: _zod.z.array(ResolvedSlotSchema)
+});
+var UpdateLayoutInputSchema = _zod.z.object({
+  slots: _zod.z.array(PageSlotSchema)
+});
+
+// src/types/config.ts
+
+var LexConfigSchema = _zod.z.object({
+  $schema: _zod.z.string().optional(),
+  version: _zod.z.number().int(),
+  name: _zod.z.string(),
+  projectId: _zod.z.string(),
+  tokens: _zod.z.object({
+    source: _zod.z.string(),
+    css: _zod.z.string(),
+    overrides: _zod.z.record(_zod.z.string(), _zod.z.unknown()).optional()
+  }).optional(),
+  kuds: _zod.z.object({
+    typesFile: _zod.z.string(),
+    componentsDir: _zod.z.string(),
+    registry: _zod.z.string().default("kuds.registry.json"),
+    autoSync: _zod.z.boolean().default(false)
+  }).optional(),
+  figma: _zod.z.object({
+    fileKey: _zod.z.string(),
+    variableCollections: _zod.z.array(_zod.z.string()).optional()
+  }).optional(),
+  api: _zod.z.object({
+    baseUrl: _zod.z.string(),
+    token: _zod.z.string(),
+    routes: _zod.z.string().default("/api/314-lex")
+  }).optional(),
+  github: _zod.z.object({
+    repo: _zod.z.string(),
+    branchPrefix: _zod.z.string().optional()
+  }).optional()
+});
+var LexClientOptionsSchema = _zod.z.object({
+  baseUrl: _zod.z.string().url(),
+  token: _zod.z.string().min(1),
+  projectId: _zod.z.string().min(1),
+  fetch: _zod.z.function().optional()
+});
+
+// src/types/tokens.ts
+
+var DesignTokenSchema = _zod.z.object({
+  id: _zod.z.string().uuid(),
+  projectId: _zod.z.string(),
+  collection: _zod.z.string(),
+  name: _zod.z.string(),
+  valueLight: _zod.z.unknown().nullable().optional(),
+  valueDark: _zod.z.unknown().nullable().optional(),
+  figmaVariableId: _zod.z.string().nullable().optional(),
+  updatedAt: _zod.z.string()
+});
+var DTCGTokenSchema = _zod.z.object({
+  $value: _zod.z.unknown(),
+  $type: _zod.z.string().optional(),
+  $description: _zod.z.string().optional()
+});
+
+// src/index.ts
+function createLexClient(options) {
+  const api = createApiClient(options);
+  return {
+    kuds: createKudsClient(api, options.projectId),
+    kuis: createKuisClient(api, options.projectId),
+    layouts: createLayoutsClient(api, options.projectId),
+    tokens: createTokensClient(api, options.projectId),
+    config: createConfigClient(api, options.projectId)
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.LexApiError = LexApiError; exports.LexValidationError = LexValidationError; exports.LexConfigError = LexConfigError; exports.KUDFieldTypeSchema = KUDFieldTypeSchema; exports.KUDFieldDefSchema = KUDFieldDefSchema; exports.KUDSchema = KUDSchema; exports.CreateKUDInputSchema = CreateKUDInputSchema; exports.UpdateKUDInputSchema = UpdateKUDInputSchema; exports.KudRegistryEntrySchema = KudRegistryEntrySchema; exports.KudRegistrySchema = KudRegistrySchema; exports.IntentVectorSchema = IntentVectorSchema; exports.KUIStatusSchema = KUIStatusSchema; exports.KUISchema = KUISchema; exports.CreateKUIInputSchema = CreateKUIInputSchema; exports.UpdateKUIInputSchema = UpdateKUIInputSchema; exports.ResolveKUIInputSchema = ResolveKUIInputSchema; exports.ListKUIsFilterSchema = ListKUIsFilterSchema; exports.PageSlotSchema = PageSlotSchema; exports.PageLayoutSchema = PageLayoutSchema; exports.ResolvedSlotSchema = ResolvedSlotSchema; exports.ResolvedPageSchema = ResolvedPageSchema; exports.UpdateLayoutInputSchema = UpdateLayoutInputSchema; exports.LexConfigSchema = LexConfigSchema; exports.LexClientOptionsSchema = LexClientOptionsSchema; exports.DesignTokenSchema = DesignTokenSchema; exports.DTCGTokenSchema = DTCGTokenSchema; exports.createLexClient = createLexClient;
+//# sourceMappingURL=chunk-HGZJ53NR.cjs.map