p1-polymorph-studio 0.1.0

package/dist/chunk-BCH2RATL.js

@@ -0,0 +1,817 @@
+// 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 = 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 {
+        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
+import { readFile, writeFile } from "fs/promises";
+
+// src/types/registry.ts
+import { z as z2 } from "zod";
+
+// src/types/kud.ts
+import { z } from "zod";
+var KUDFieldTypeSchema = z.enum([
+  "string",
+  "text",
+  "number",
+  "boolean",
+  "image",
+  "link",
+  "array",
+  "object"
+]);
+var KUDFieldDefSchema = z.lazy(
+  () => z.object({
+    type: KUDFieldTypeSchema,
+    required: z.boolean().optional(),
+    description: z.string().optional(),
+    items: KUDFieldDefSchema.optional(),
+    properties: z.record(z.string(), KUDFieldDefSchema).optional()
+  })
+);
+var KUDSchema = z.object({
+  id: z.string().uuid(),
+  projectId: z.string(),
+  type: z.string(),
+  label: z.string().nullable().optional(),
+  version: z.number().int().default(1),
+  schema: z.record(z.string(), KUDFieldDefSchema),
+  defaultKuiId: z.string().uuid().nullable().optional(),
+  metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var CreateKUDInputSchema = z.object({
+  type: z.string().min(1),
+  label: z.string().optional(),
+  schema: z.record(z.string(), KUDFieldDefSchema),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+var UpdateKUDInputSchema = z.object({
+  label: z.string().optional(),
+  schema: z.record(z.string(), KUDFieldDefSchema).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+
+// src/types/registry.ts
+var KudRegistryEntrySchema = z2.object({
+  type: z2.string(),
+  label: z2.string().optional(),
+  version: z2.number().int().default(1),
+  schema: z2.record(z2.string(), KUDFieldDefSchema),
+  componentPath: z2.string().optional(),
+  metadata: z2.record(z2.string(), z2.unknown()).optional()
+});
+var KudRegistrySchema = z2.object({
+  version: z2.number().int().default(1),
+  projectId: z2.string(),
+  generatedAt: z2.string(),
+  kuds: z2.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 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 readFile(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: kud.label ?? void 0,
+          version: kud.version,
+          schema: kud.schema,
+          metadata: kud.metadata ?? void 0
+        }))
+      };
+      await writeFile(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 = 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 (filter?.kudType) params.kud_type = filter.kudType;
+      if (filter?.locale) params.locale = filter.locale;
+      if (filter?.status) params.status = filter.status;
+      if (filter?.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 > (bestKui?.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: opts.locale ?? "en",
+          intentVector: opts.intentVector,
+          intentVelocity: opts.intentVelocity,
+          velocityWeight: opts.velocityWeight
+        });
+      } catch (err) {
+        if (err instanceof LexApiError && err.statusCode === 404) {
+          const locale = 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 > (bestKui?.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
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+
+// 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 = 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 readFile2(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 writeFile2(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 = modes[0]?.[1];
+        const darkValue = modes[1]?.[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
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { watch as fsWatchSync } from "fs";
+function createConfigClient(api, projectId) {
+  return {
+    async generate(outputPath = "314-lex.config.json") {
+      let existing = {};
+      try {
+        const raw = await readFile3(outputPath, "utf-8");
+        existing = JSON.parse(raw);
+      } catch {
+      }
+      const config = {
+        $schema: "https://unpkg.com/@314-lex/sdk/schema/config.json",
+        version: 2,
+        name: existing.name ?? projectId,
+        projectId: existing.projectId ?? projectId,
+        tokens: existing.tokens,
+        kuds: existing.kuds,
+        figma: existing.figma,
+        api: existing.api ?? {
+          baseUrl: "env:POLYMORPH_BASE_URL",
+          token: "env:POLYMORPH_TOKEN",
+          routes: "/api/314-lex"
+        },
+        github: existing.github
+      };
+      await writeFile3(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: kud.label ?? void 0,
+          version: kud.version,
+          schema: kud.schema,
+          metadata: kud.metadata ?? void 0
+        }))
+      };
+      await writeFile3(outputPath, JSON.stringify(registry, null, 2) + "\n", "utf-8");
+    },
+    watch(opts) {
+      const watchers = [];
+      for (const path of opts.paths) {
+        const watcher = fsWatchSync(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
+import { z as z3 } from "zod";
+var IntentVectorSchema = z3.tuple([
+  z3.number(),
+  z3.number(),
+  z3.number(),
+  z3.number(),
+  z3.number()
+]);
+var KUIStatusSchema = z3.enum(["draft", "published", "archived"]);
+var KUISchema = z3.object({
+  id: z3.string().uuid(),
+  kudId: z3.string().uuid(),
+  kudType: z3.string(),
+  projectId: z3.string(),
+  locale: z3.string().default("en"),
+  intentAffinity: IntentVectorSchema,
+  intentVelocity: IntentVectorSchema.nullable().optional(),
+  priority: z3.number().int().default(0),
+  content: z3.record(z3.string(), z3.unknown()),
+  metadata: z3.record(z3.string(), z3.unknown()).nullable().optional(),
+  status: KUIStatusSchema.default("draft"),
+  createdAt: z3.string(),
+  updatedAt: z3.string()
+});
+var CreateKUIInputSchema = z3.object({
+  kudType: z3.string().min(1),
+  locale: z3.string().default("en"),
+  intentAffinity: IntentVectorSchema,
+  intentVelocity: IntentVectorSchema.optional(),
+  priority: z3.number().int().default(0),
+  content: z3.record(z3.string(), z3.unknown()),
+  metadata: z3.record(z3.string(), z3.unknown()).optional()
+});
+var UpdateKUIInputSchema = z3.object({
+  locale: z3.string().optional(),
+  intentAffinity: IntentVectorSchema.optional(),
+  intentVelocity: IntentVectorSchema.nullable().optional(),
+  priority: z3.number().int().optional(),
+  content: z3.record(z3.string(), z3.unknown()).optional(),
+  metadata: z3.record(z3.string(), z3.unknown()).optional(),
+  status: KUIStatusSchema.optional()
+});
+var ResolveKUIInputSchema = z3.object({
+  kudType: z3.string().min(1),
+  intentVector: IntentVectorSchema,
+  intentVelocity: IntentVectorSchema.optional(),
+  velocityWeight: z3.number().min(0).max(1).default(0.3),
+  locale: z3.string().default("en")
+});
+var ListKUIsFilterSchema = z3.object({
+  kudType: z3.string().optional(),
+  locale: z3.string().optional(),
+  status: KUIStatusSchema.optional(),
+  intentStage: z3.enum(["awareness", "interest", "consideration", "decision", "evaluation"]).optional()
+});
+
+// src/types/layout.ts
+import { z as z4 } from "zod";
+var PageSlotSchema = z4.object({
+  slotId: z4.string(),
+  kudId: z4.string(),
+  required: z4.boolean().default(true),
+  candidateKuiIds: z4.array(z4.string()).optional()
+});
+var PageLayoutSchema = z4.object({
+  id: z4.string().uuid(),
+  projectId: z4.string(),
+  pageId: z4.string(),
+  locale: z4.string().default("en"),
+  slots: z4.array(PageSlotSchema),
+  createdAt: z4.string(),
+  updatedAt: z4.string()
+});
+var ResolvedSlotSchema = z4.object({
+  slotId: z4.string(),
+  kui: KUISchema,
+  score: z4.number()
+});
+var ResolvedPageSchema = z4.object({
+  pageId: z4.string(),
+  slots: z4.array(ResolvedSlotSchema)
+});
+var UpdateLayoutInputSchema = z4.object({
+  slots: z4.array(PageSlotSchema)
+});
+
+// src/types/config.ts
+import { z as z5 } from "zod";
+var LexConfigSchema = z5.object({
+  $schema: z5.string().optional(),
+  version: z5.number().int(),
+  name: z5.string(),
+  projectId: z5.string(),
+  tokens: z5.object({
+    source: z5.string(),
+    css: z5.string(),
+    overrides: z5.record(z5.string(), z5.unknown()).optional()
+  }).optional(),
+  kuds: z5.object({
+    typesFile: z5.string(),
+    componentsDir: z5.string(),
+    registry: z5.string().default("kuds.registry.json"),
+    autoSync: z5.boolean().default(false)
+  }).optional(),
+  figma: z5.object({
+    fileKey: z5.string(),
+    variableCollections: z5.array(z5.string()).optional()
+  }).optional(),
+  api: z5.object({
+    baseUrl: z5.string(),
+    token: z5.string(),
+    routes: z5.string().default("/api/314-lex")
+  }).optional(),
+  github: z5.object({
+    repo: z5.string(),
+    branchPrefix: z5.string().optional()
+  }).optional()
+});
+var LexClientOptionsSchema = z5.object({
+  baseUrl: z5.string().url(),
+  token: z5.string().min(1),
+  projectId: z5.string().min(1),
+  fetch: z5.function().optional()
+});
+
+// src/types/tokens.ts
+import { z as z6 } from "zod";
+var DesignTokenSchema = z6.object({
+  id: z6.string().uuid(),
+  projectId: z6.string(),
+  collection: z6.string(),
+  name: z6.string(),
+  valueLight: z6.unknown().nullable().optional(),
+  valueDark: z6.unknown().nullable().optional(),
+  figmaVariableId: z6.string().nullable().optional(),
+  updatedAt: z6.string()
+});
+var DTCGTokenSchema = z6.object({
+  $value: z6.unknown(),
+  $type: z6.string().optional(),
+  $description: z6.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)
+  };
+}
+
+export {
+  LexApiError,
+  LexValidationError,
+  LexConfigError,
+  KUDFieldTypeSchema,
+  KUDFieldDefSchema,
+  KUDSchema,
+  CreateKUDInputSchema,
+  UpdateKUDInputSchema,
+  KudRegistryEntrySchema,
+  KudRegistrySchema,
+  IntentVectorSchema,
+  KUIStatusSchema,
+  KUISchema,
+  CreateKUIInputSchema,
+  UpdateKUIInputSchema,
+  ResolveKUIInputSchema,
+  ListKUIsFilterSchema,
+  PageSlotSchema,
+  PageLayoutSchema,
+  ResolvedSlotSchema,
+  ResolvedPageSchema,
+  UpdateLayoutInputSchema,
+  LexConfigSchema,
+  LexClientOptionsSchema,
+  DesignTokenSchema,
+  DTCGTokenSchema,
+  createLexClient
+};
+//# sourceMappingURL=chunk-BCH2RATL.js.map