@toothfairyai/tfdesign 0.4.3 → 0.4.5

package/dist/{chunk-P6IOSGAC.js → chunk-VIER63EE.js}

@@ -9,8 +9,8 @@ import { execFile as execFile5, spawn as spawn3 } from "node:child_process";
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { createRequire } from "node:module";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import path28 from "node:path";
-import fs7 from "node:fs";
+import path29 from "node:path";
+import fs8 from "node:fs";
 import os4 from "node:os";
 import net2 from "node:net";
 
@@ -4022,7 +4022,7 @@ async function extractBrandFromUrl(url) {
   const trimmed = normalizeUrl(url ?? "");
   if (!trimmed) throw new Error("url is required");
   setDesignlangBrowsersPath();
-  const api = await import("designlang/api");
+  const api = await import("./api-2ZCSAOJG.js");
   const design = await api.extract(trimmed);
   const extraction = mapDesignToExtraction(design, api.render, trimmed);
   extraction.images = await harvestImages(trimmed, extraction.ogImage);
@@ -6495,8 +6495,8 @@ function getErrorMap() {
 
 // node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path29, errorMaps, issueData } = params;
-  const fullPath = [...path29, ...issueData.path || []];
+  const { data, path: path30, errorMaps, issueData } = params;
+  const fullPath = [...path30, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -6612,11 +6612,11 @@ var errorUtil;
 
 // node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path29, key) {
+  constructor(parent, value, path30, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path29;
+    this._path = path30;
     this._key = key;
   }
   get path() {
@@ -14368,9 +14368,9 @@ function parseDeclarations(body) {
   return out;
 }
 function resolveFontSizePx(decls) {
-  const fs8 = findLastDecl(decls, "font-size");
-  if (!fs8) return null;
-  const m = /^(-?\d*\.?\d+)\s*(px|rem)\b/i.exec(fs8.value);
+  const fs9 = findLastDecl(decls, "font-size");
+  if (!fs9) return null;
+  const m = /^(-?\d*\.?\d+)\s*(px|rem)\b/i.exec(fs9.value);
   if (!m) return null;
   const v = parseFloat(m[1]);
   const unit = m[2].toLowerCase();
@@ -16959,37 +16959,37 @@ function isPlainObject2(value) {
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || proto === null;
 }
-function asString(value, path29, issues, max = MAX_SHORT_TEXT_LENGTH) {
+function asString(value, path30, issues, max = MAX_SHORT_TEXT_LENGTH) {
   if (typeof value !== "string") {
-    issues.push({ path: path29, message: `${path29} must be a string` });
+    issues.push({ path: path30, message: `${path30} must be a string` });
     return void 0;
   }
   if (value.length === 0) {
-    issues.push({ path: path29, message: `${path29} is required` });
+    issues.push({ path: path30, message: `${path30} is required` });
   }
   if (value.length > max) {
-    issues.push({ path: path29, message: `${path29} exceeds max length (${max})` });
+    issues.push({ path: path30, message: `${path30} exceeds max length (${max})` });
   }
   return value;
 }
-function asOptionalString(value, path29, issues, max = MAX_SHORT_TEXT_LENGTH) {
+function asOptionalString(value, path30, issues, max = MAX_SHORT_TEXT_LENGTH) {
   if (value === void 0) return void 0;
-  return asString(value, path29, issues, max);
+  return asString(value, path30, issues, max);
 }
-function asBoolean(value, path29, issues) {
+function asBoolean(value, path30, issues) {
   if (typeof value !== "boolean") {
-    issues.push({ path: path29, message: `${path29} must be a boolean` });
+    issues.push({ path: path30, message: `${path30} must be a boolean` });
     return void 0;
   }
   return value;
 }
-function asOptionalBoolean(value, path29, issues) {
+function asOptionalBoolean(value, path30, issues) {
   if (value === void 0) return void 0;
-  return asBoolean(value, path29, issues);
+  return asBoolean(value, path30, issues);
 }
-function validateEnum(value, allowed, path29, issues) {
+function validateEnum(value, allowed, path30, issues) {
   if (typeof value !== "string" || !allowed.has(value)) {
-    issues.push({ path: path29, message: `${path29} is not allowed` });
+    issues.push({ path: path30, message: `${path30} is not allowed` });
     return void 0;
   }
   return value;
@@ -16998,26 +16998,26 @@ function isIsoDateString(value) {
   const time = Date.parse(value);
   return Number.isFinite(time) && new Date(time).toISOString() === value;
 }
-function validateIsoDate(value, path29, issues) {
-  const text = asString(value, path29, issues, MAX_SHORT_TEXT_LENGTH);
+function validateIsoDate(value, path30, issues) {
+  const text = asString(value, path30, issues, MAX_SHORT_TEXT_LENGTH);
   if (text !== void 0 && !isIsoDateString(text)) {
-    issues.push({ path: path29, message: `${path29} must be an ISO-8601 timestamp` });
+    issues.push({ path: path30, message: `${path30} must be an ISO-8601 timestamp` });
   }
   return text;
 }
-function validateRelativePath(value, path29, issues) {
+function validateRelativePath(value, path30, issues) {
   if (value.length > MAX_PATH_LENGTH) {
-    issues.push({ path: path29, message: `${path29} exceeds max length (${MAX_PATH_LENGTH})` });
+    issues.push({ path: path30, message: `${path30} exceeds max length (${MAX_PATH_LENGTH})` });
   }
   if (value.includes("\0")) {
-    issues.push({ path: path29, message: `${path29} cannot contain null bytes` });
+    issues.push({ path: path30, message: `${path30} cannot contain null bytes` });
   }
   const normalized = value.replace(/\\/g, "/");
   if (normalized.startsWith("/") || /^[A-Za-z]:/.test(normalized)) {
-    issues.push({ path: path29, message: `${path29} cannot be an absolute path` });
+    issues.push({ path: path30, message: `${path30} cannot be an absolute path` });
   }
   if (normalized.split("/").some((part) => part === "..")) {
-    issues.push({ path: path29, message: `${path29} cannot contain path traversal` });
+    issues.push({ path: path30, message: `${path30} cannot contain path traversal` });
   }
 }
 function validateNoDaemonOwnedFields(raw, issues) {
@@ -17027,17 +17027,17 @@ function validateNoDaemonOwnedFields(raw, issues) {
     }
   }
 }
-function validateOnlyAllowedKeys(raw, allowed, path29, issues) {
+function validateOnlyAllowedKeys(raw, allowed, path30, issues) {
   for (const key of Object.keys(raw)) {
     if (!allowed.has(key)) {
-      issues.push({ path: `${path29}.${key}`, message: `${path29}.${key} is not allowed` });
+      issues.push({ path: `${path30}.${key}`, message: `${path30}.${key} is not allowed` });
     }
   }
 }
-function validateBoundedJsonInternal(value, path29, issues, depth) {
+function validateBoundedJsonInternal(value, path30, issues, depth) {
   if (value === null || typeof value === "boolean" || typeof value === "number") {
     if (typeof value === "number" && !Number.isFinite(value)) {
-      issues.push({ path: path29, message: `${path29} must be a finite number` });
+      issues.push({ path: path30, message: `${path30} must be a finite number` });
       return false;
     }
     return true;
@@ -17045,8 +17045,8 @@ function validateBoundedJsonInternal(value, path29, issues, depth) {
   if (typeof value === "string") {
     if (value.length > LIVE_ARTIFACT_BOUNDED_JSON_CONSTRAINTS.maxStringLength) {
       issues.push({
-        path: path29,
-        message: `${path29} exceeds max string length (${LIVE_ARTIFACT_BOUNDED_JSON_CONSTRAINTS.maxStringLength})`
+        path: path30,
+        message: `${path30} exceeds max string length (${LIVE_ARTIFACT_BOUNDED_JSON_CONSTRAINTS.maxStringLength})`
       });
       return false;
     }
@@ -17054,128 +17054,128 @@ function validateBoundedJsonInternal(value, path29, issues, depth) {
   }
   if (Array.isArray(value)) {
     if (depth > LIVE_ARTIFACT_BOUNDED_JSON_CONSTRAINTS.maxDepth) {
-      issues.push({ path: path29, message: `${path29} exceeds max JSON depth (${LIVE_ARTIFACT_BOUNDED_JSON_CONSTRAINTS.maxDepth})` });
+      issues.push({ path: path30, message: `${path30} exceeds max JSON depth (${LIVE_ARTIFACT_BOUNDED_JSON_CONSTRAINTS.maxDepth})` });
       return false;
     }
     if (value.length > LIVE_ARTIFACT_BOUNDED_JSON_CONSTRAINTS.maxArrayLength) {
       issues.push({
-        path: path29,
-        message: `${path29} exceeds max array length (${LIVE_ARTIFACT_BOUNDED_JSON_CONSTRAINTS.maxArrayLength})`
+        path: path30,
+        message: `${path30} exceeds max array length (${LIVE_ARTIFACT_BOUNDED_JSON_CONSTRAINTS.maxArrayLength})`
       });
       return false;
     }
-    return value.every((item, index) => validateBoundedJsonInternal(item, `${path29}.${index}`, issues, depth + 1));
+    return value.every((item, index) => validateBoundedJsonInternal(item, `${path30}.${index}`, issues, depth + 1));
   }
   if (isPlainObject2(value)) {
     if (depth > LIVE_ARTIFACT_BOUNDED_JSON_CONSTRAINTS.maxDepth) {
-      issues.push({ path: path29, message: `${path29} exceeds max JSON depth (${LIVE_ARTIFACT_BOUNDED_JSON_CONSTRAINTS.maxDepth})` });
+      issues.push({ path: path30, message: `${path30} exceeds max JSON depth (${LIVE_ARTIFACT_BOUNDED_JSON_CONSTRAINTS.maxDepth})` });
       return false;
     }
     const entries = Object.entries(value);
     if (entries.length > LIVE_ARTIFACT_BOUNDED_JSON_CONSTRAINTS.maxObjectKeys) {
       issues.push({
-        path: path29,
-        message: `${path29} exceeds max object keys (${LIVE_ARTIFACT_BOUNDED_JSON_CONSTRAINTS.maxObjectKeys})`
+        path: path30,
+        message: `${path30} exceeds max object keys (${LIVE_ARTIFACT_BOUNDED_JSON_CONSTRAINTS.maxObjectKeys})`
       });
       return false;
     }
     let valid = true;
     for (const [key, child] of entries) {
       if (FORBIDDEN_JSON_KEYS.has(key.toLowerCase())) {
-        issues.push({ path: `${path29}.${key}`, message: `${path29}.${key} uses a forbidden key` });
+        issues.push({ path: `${path30}.${key}`, message: `${path30}.${key} uses a forbidden key` });
         valid = false;
       }
-      valid = validateBoundedJsonInternal(child, `${path29}.${key}`, issues, depth + 1) && valid;
+      valid = validateBoundedJsonInternal(child, `${path30}.${key}`, issues, depth + 1) && valid;
     }
     return valid;
   }
-  issues.push({ path: path29, message: `${path29} must be JSON-serializable` });
+  issues.push({ path: path30, message: `${path30} must be JSON-serializable` });
   return false;
 }
-function validateBoundedJsonValue(value, path29 = "value") {
+function validateBoundedJsonValue(value, path30 = "value") {
   const issues = [];
-  if (validateBoundedJsonInternal(value, path29, issues, 1)) {
+  if (validateBoundedJsonInternal(value, path30, issues, 1)) {
     const serialized = JSON.stringify(value);
     if (Buffer.byteLength(serialized, "utf8") <= LIVE_ARTIFACT_BOUNDED_JSON_CONSTRAINTS.maxSerializedBytes) {
       return ok(value);
     }
     issues.push({
-      path: path29,
-      message: `${path29} exceeds max serialized size (${LIVE_ARTIFACT_BOUNDED_JSON_CONSTRAINTS.maxSerializedBytes} bytes)`
+      path: path30,
+      message: `${path30} exceeds max serialized size (${LIVE_ARTIFACT_BOUNDED_JSON_CONSTRAINTS.maxSerializedBytes} bytes)`
     });
   }
   return fail(issues);
 }
-function validateBoundedJsonObject(value, path29 = "value") {
-  const result = validateBoundedJsonValue(value, path29);
+function validateBoundedJsonObject(value, path30 = "value") {
+  const result = validateBoundedJsonValue(value, path30);
   if (!result.ok) return result;
   if (!isPlainObject2(result.value)) {
-    return fail([{ path: path29, message: `${path29} must be a JSON object` }]);
+    return fail([{ path: path30, message: `${path30} must be a JSON object` }]);
   }
   return ok(result.value);
 }
-function validateSourceInputPaths(value, path29, issues) {
+function validateSourceInputPaths(value, path30, issues) {
   if (typeof value === "string") {
-    validateRelativePath(value, path29, issues);
+    validateRelativePath(value, path30, issues);
     return;
   }
   if (Array.isArray(value)) {
-    value.forEach((item, index) => validateSourceInputPaths(item, `${path29}.${index}`, issues));
+    value.forEach((item, index) => validateSourceInputPaths(item, `${path30}.${index}`, issues));
     return;
   }
   if (isPlainObject2(value)) {
     for (const [key, child] of Object.entries(value)) {
-      if (/path|file|glob|ref/i.test(key)) validateSourceInputPaths(child, `${path29}.${key}`, issues);
+      if (/path|file|glob|ref/i.test(key)) validateSourceInputPaths(child, `${path30}.${key}`, issues);
     }
   }
 }
-function validatePreview(value, path29, issues) {
+function validatePreview(value, path30, issues) {
   if (!isPlainObject2(value)) {
-    issues.push({ path: path29, message: `${path29} must be an object` });
+    issues.push({ path: path30, message: `${path30} must be an object` });
     return void 0;
   }
-  const type = validateEnum(value.type, PREVIEW_TYPES, `${path29}.type`, issues);
-  const entry = asString(value.entry, `${path29}.entry`, issues, MAX_PATH_LENGTH);
-  if (entry !== void 0) validateRelativePath(entry, `${path29}.entry`, issues);
+  const type = validateEnum(value.type, PREVIEW_TYPES, `${path30}.type`, issues);
+  const entry = asString(value.entry, `${path30}.entry`, issues, MAX_PATH_LENGTH);
+  if (entry !== void 0) validateRelativePath(entry, `${path30}.entry`, issues);
   if (type === void 0 || entry === void 0) return void 0;
   return { type, entry };
 }
 var SAFE_MAPPING_SEGMENT = /^[A-Za-z_][A-Za-z0-9_-]*$|^(?:0|[1-9][0-9]*)$/;
 var UNSAFE_MAPPING_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
-function validateMappingPath(value, path29, issues) {
+function validateMappingPath(value, path30, issues) {
   const normalized = value.startsWith("$.") ? value.slice(2) : value;
   if (normalized.length === 0 || normalized.startsWith(".") || normalized.endsWith(".") || normalized.includes("..")) {
-    issues.push({ path: path29, message: `${path29} must be a dot-separated JSON path` });
+    issues.push({ path: path30, message: `${path30} must be a dot-separated JSON path` });
     return;
   }
   for (const segment of normalized.split(".")) {
     if (!SAFE_MAPPING_SEGMENT.test(segment) || UNSAFE_MAPPING_SEGMENTS.has(segment)) {
-      issues.push({ path: path29, message: `${path29} contains unsupported JSON path segment: ${segment}` });
+      issues.push({ path: path30, message: `${path30} contains unsupported JSON path segment: ${segment}` });
       return;
     }
   }
 }
-function validateSource(value, path29, issues) {
+function validateSource(value, path30, issues) {
   if (!isPlainObject2(value)) {
-    issues.push({ path: path29, message: `${path29} must be an object` });
+    issues.push({ path: path30, message: `${path30} must be an object` });
     return void 0;
   }
-  validateOnlyAllowedKeys(value, SOURCE_KEYS, path29, issues);
-  const type = validateEnum(value.type, SOURCE_TYPES, `${path29}.type`, issues);
-  const toolName = asOptionalString(value.toolName, `${path29}.toolName`, issues, MAX_ID_LENGTH);
-  const inputResult = validateBoundedJsonObject(value.input, `${path29}.input`);
+  validateOnlyAllowedKeys(value, SOURCE_KEYS, path30, issues);
+  const type = validateEnum(value.type, SOURCE_TYPES, `${path30}.type`, issues);
+  const toolName = asOptionalString(value.toolName, `${path30}.toolName`, issues, MAX_ID_LENGTH);
+  const inputResult = validateBoundedJsonObject(value.input, `${path30}.input`);
   if (!inputResult.ok) issues.push(...inputResult.issues);
-  else validateSourceInputPaths(inputResult.value, `${path29}.input`, issues);
+  else validateSourceInputPaths(inputResult.value, `${path30}.input`, issues);
   let connector;
   if (value.connector !== void 0) {
     if (!isPlainObject2(value.connector)) {
-      issues.push({ path: `${path29}.connector`, message: `${path29}.connector must be an object` });
+      issues.push({ path: `${path30}.connector`, message: `${path30}.connector must be an object` });
     } else {
-      validateOnlyAllowedKeys(value.connector, CONNECTOR_REFERENCE_KEYS, `${path29}.connector`, issues);
-      const connectorId = asString(value.connector.connectorId, `${path29}.connector.connectorId`, issues, MAX_ID_LENGTH);
-      const accountLabel = asOptionalString(value.connector.accountLabel, `${path29}.connector.accountLabel`, issues, MAX_SHORT_TEXT_LENGTH);
-      const connectorToolName = asString(value.connector.toolName, `${path29}.connector.toolName`, issues, MAX_ID_LENGTH);
-      const approvalPolicy = value.connector.approvalPolicy === void 0 ? void 0 : validateEnum(value.connector.approvalPolicy, CONNECTOR_APPROVAL_POLICIES, `${path29}.connector.approvalPolicy`, issues);
+      validateOnlyAllowedKeys(value.connector, CONNECTOR_REFERENCE_KEYS, `${path30}.connector`, issues);
+      const connectorId = asString(value.connector.connectorId, `${path30}.connector.connectorId`, issues, MAX_ID_LENGTH);
+      const accountLabel = asOptionalString(value.connector.accountLabel, `${path30}.connector.accountLabel`, issues, MAX_SHORT_TEXT_LENGTH);
+      const connectorToolName = asString(value.connector.toolName, `${path30}.connector.toolName`, issues, MAX_ID_LENGTH);
+      const approvalPolicy = value.connector.approvalPolicy === void 0 ? void 0 : validateEnum(value.connector.approvalPolicy, CONNECTOR_APPROVAL_POLICIES, `${path30}.connector.approvalPolicy`, issues);
       if (connectorId !== void 0 && connectorToolName !== void 0) {
         const nextConnector = { connectorId, toolName: connectorToolName };
         if (accountLabel !== void 0) nextConnector.accountLabel = accountLabel;
@@ -17187,17 +17187,17 @@ function validateSource(value, path29, issues) {
   let outputMapping;
   if (value.outputMapping !== void 0) {
     if (!isPlainObject2(value.outputMapping)) {
-      issues.push({ path: `${path29}.outputMapping`, message: `${path29}.outputMapping must be an object` });
+      issues.push({ path: `${path30}.outputMapping`, message: `${path30}.outputMapping must be an object` });
     } else {
-      validateOnlyAllowedKeys(value.outputMapping, OUTPUT_MAPPING_KEYS, `${path29}.outputMapping`, issues);
+      validateOnlyAllowedKeys(value.outputMapping, OUTPUT_MAPPING_KEYS, `${path30}.outputMapping`, issues);
       const mapping = {};
       if (value.outputMapping.dataPaths !== void 0) {
         if (!Array.isArray(value.outputMapping.dataPaths) || value.outputMapping.dataPaths.length > MAX_MAPPING_PATHS) {
-          issues.push({ path: `${path29}.outputMapping.dataPaths`, message: `${path29}.outputMapping.dataPaths must be a bounded array` });
+          issues.push({ path: `${path30}.outputMapping.dataPaths`, message: `${path30}.outputMapping.dataPaths must be a bounded array` });
         } else {
           mapping.dataPaths = [];
           value.outputMapping.dataPaths.forEach((item, index) => {
-            const itemPath = `${path29}.outputMapping.dataPaths.${index}`;
+            const itemPath = `${path30}.outputMapping.dataPaths.${index}`;
             if (!isPlainObject2(item)) {
               issues.push({ path: itemPath, message: `${itemPath} must be an object` });
               return;
@@ -17211,21 +17211,21 @@ function validateSource(value, path29, issues) {
         }
       }
       if (value.outputMapping.transform !== void 0) {
-        const transform = validateEnum(value.outputMapping.transform, OUTPUT_TRANSFORMS, `${path29}.outputMapping.transform`, issues);
+        const transform = validateEnum(value.outputMapping.transform, OUTPUT_TRANSFORMS, `${path30}.outputMapping.transform`, issues);
         if (transform !== void 0) mapping.transform = transform;
       }
       outputMapping = mapping;
     }
   }
-  const refreshPermission = validateEnum(value.refreshPermission, REFRESH_PERMISSIONS, `${path29}.refreshPermission`, issues);
+  const refreshPermission = validateEnum(value.refreshPermission, REFRESH_PERMISSIONS, `${path30}.refreshPermission`, issues);
   if (type === "connector_tool" && connector === void 0) {
-    issues.push({ path: `${path29}.connector`, message: `${path29}.connector is required for connector_tool sources` });
+    issues.push({ path: `${path30}.connector`, message: `${path30}.connector is required for connector_tool sources` });
   }
   if (type === "connector_tool" && toolName !== void 0 && connector !== void 0 && toolName !== connector.toolName) {
-    issues.push({ path: `${path29}.toolName`, message: `${path29}.toolName must match ${path29}.connector.toolName` });
+    issues.push({ path: `${path30}.toolName`, message: `${path30}.toolName must match ${path30}.connector.toolName` });
   }
   if (type === "daemon_tool" && toolName === void 0) {
-    issues.push({ path: `${path29}.toolName`, message: `${path29}.toolName is required for daemon_tool sources` });
+    issues.push({ path: `${path30}.toolName`, message: `${path30}.toolName is required for daemon_tool sources` });
   }
   if (type === void 0 || !inputResult.ok || refreshPermission === void 0) return void 0;
   const source = { type, input: inputResult.value, refreshPermission };
@@ -17234,24 +17234,24 @@ function validateSource(value, path29, issues) {
   if (outputMapping !== void 0) source.outputMapping = outputMapping;
   return source;
 }
-function validateRefreshSourceMetadata(value, path29, issues) {
+function validateRefreshSourceMetadata(value, path30, issues) {
   if (!isPlainObject2(value)) {
-    issues.push({ path: path29, message: `${path29} must be an object` });
+    issues.push({ path: path30, message: `${path30} must be an object` });
     return void 0;
   }
-  validateOnlyAllowedKeys(value, REFRESH_SOURCE_METADATA_KEYS, path29, issues);
-  const sourceType = validateEnum(value.sourceType, REFRESH_SOURCE_TYPES, `${path29}.sourceType`, issues);
-  const toolName = asOptionalString(value.toolName, `${path29}.toolName`, issues, MAX_ID_LENGTH);
+  validateOnlyAllowedKeys(value, REFRESH_SOURCE_METADATA_KEYS, path30, issues);
+  const sourceType = validateEnum(value.sourceType, REFRESH_SOURCE_TYPES, `${path30}.sourceType`, issues);
+  const toolName = asOptionalString(value.toolName, `${path30}.toolName`, issues, MAX_ID_LENGTH);
   let connector;
   if (value.connector !== void 0) {
     if (!isPlainObject2(value.connector)) {
-      issues.push({ path: `${path29}.connector`, message: `${path29}.connector must be an object` });
+      issues.push({ path: `${path30}.connector`, message: `${path30}.connector must be an object` });
     } else {
-      validateOnlyAllowedKeys(value.connector, CONNECTOR_REFERENCE_KEYS, `${path29}.connector`, issues);
-      const connectorId = asString(value.connector.connectorId, `${path29}.connector.connectorId`, issues, MAX_ID_LENGTH);
-      const accountLabel = asOptionalString(value.connector.accountLabel, `${path29}.connector.accountLabel`, issues, MAX_SHORT_TEXT_LENGTH);
-      const connectorToolName = asString(value.connector.toolName, `${path29}.connector.toolName`, issues, MAX_ID_LENGTH);
-      const approvalPolicy = value.connector.approvalPolicy === void 0 ? void 0 : validateEnum(value.connector.approvalPolicy, CONNECTOR_APPROVAL_POLICIES, `${path29}.connector.approvalPolicy`, issues);
+      validateOnlyAllowedKeys(value.connector, CONNECTOR_REFERENCE_KEYS, `${path30}.connector`, issues);
+      const connectorId = asString(value.connector.connectorId, `${path30}.connector.connectorId`, issues, MAX_ID_LENGTH);
+      const accountLabel = asOptionalString(value.connector.accountLabel, `${path30}.connector.accountLabel`, issues, MAX_SHORT_TEXT_LENGTH);
+      const connectorToolName = asString(value.connector.toolName, `${path30}.connector.toolName`, issues, MAX_ID_LENGTH);
+      const approvalPolicy = value.connector.approvalPolicy === void 0 ? void 0 : validateEnum(value.connector.approvalPolicy, CONNECTOR_APPROVAL_POLICIES, `${path30}.connector.approvalPolicy`, issues);
       if (connectorId !== void 0 && connectorToolName !== void 0) {
         connector = { connectorId, toolName: connectorToolName };
         if (accountLabel !== void 0) connector.accountLabel = accountLabel;
@@ -17265,46 +17265,46 @@ function validateRefreshSourceMetadata(value, path29, issues) {
   if (connector !== void 0) source.connector = connector;
   return source;
 }
-function validateRefreshErrorRecord(value, path29, issues) {
+function validateRefreshErrorRecord(value, path30, issues) {
   if (!isPlainObject2(value)) {
-    issues.push({ path: path29, message: `${path29} must be an object` });
+    issues.push({ path: path30, message: `${path30} must be an object` });
     return void 0;
   }
-  const code = asOptionalString(value.code, `${path29}.code`, issues, MAX_REFRESH_ERROR_CODE_LENGTH);
-  const message = asString(value.message, `${path29}.message`, issues, MAX_REFRESH_ERROR_MESSAGE_LENGTH);
-  const errorPath = asOptionalString(value.path, `${path29}.path`, issues, MAX_PATH_LENGTH);
+  const code = asOptionalString(value.code, `${path30}.code`, issues, MAX_REFRESH_ERROR_CODE_LENGTH);
+  const message = asString(value.message, `${path30}.message`, issues, MAX_REFRESH_ERROR_MESSAGE_LENGTH);
+  const errorPath = asOptionalString(value.path, `${path30}.path`, issues, MAX_PATH_LENGTH);
   if (message === void 0) return void 0;
   const record = { message };
   if (code !== void 0) record.code = code;
   if (errorPath !== void 0) record.path = errorPath;
   return record;
 }
-function validateOptionalInteger(value, path29, issues, min, max) {
+function validateOptionalInteger(value, path30, issues, min, max) {
   if (value === void 0) return void 0;
   if (typeof value !== "number" || !Number.isInteger(value) || value < min || value > max) {
-    issues.push({ path: path29, message: `${path29} must be an integer between ${min} and ${max}` });
+    issues.push({ path: path30, message: `${path30} must be an integer between ${min} and ${max}` });
     return void 0;
   }
   return value;
 }
-function validateDocument(value, path29, issues) {
+function validateDocument(value, path30, issues) {
   if (!isPlainObject2(value)) {
-    issues.push({ path: path29, message: `${path29} must be an object` });
+    issues.push({ path: path30, message: `${path30} must be an object` });
     return void 0;
   }
-  if (value.format !== "html_template_v1") issues.push({ path: `${path29}.format`, message: `${path29}.format must be html_template_v1` });
-  if (value.templatePath !== "template.html") issues.push({ path: `${path29}.templatePath`, message: `${path29}.templatePath must be template.html` });
-  if (value.generatedPreviewPath !== "index.html") issues.push({ path: `${path29}.generatedPreviewPath`, message: `${path29}.generatedPreviewPath must be index.html` });
-  if (value.dataPath !== "data.json") issues.push({ path: `${path29}.dataPath`, message: `${path29}.dataPath must be data.json` });
-  const dataJsonResult = validateBoundedJsonObject(value.dataJson, `${path29}.dataJson`);
+  if (value.format !== "html_template_v1") issues.push({ path: `${path30}.format`, message: `${path30}.format must be html_template_v1` });
+  if (value.templatePath !== "template.html") issues.push({ path: `${path30}.templatePath`, message: `${path30}.templatePath must be template.html` });
+  if (value.generatedPreviewPath !== "index.html") issues.push({ path: `${path30}.generatedPreviewPath`, message: `${path30}.generatedPreviewPath must be index.html` });
+  if (value.dataPath !== "data.json") issues.push({ path: `${path30}.dataPath`, message: `${path30}.dataPath must be data.json` });
+  const dataJsonResult = validateBoundedJsonObject(value.dataJson, `${path30}.dataJson`);
   if (!dataJsonResult.ok) issues.push(...dataJsonResult.issues);
   let dataSchemaJson;
   if (value.dataSchemaJson !== void 0) {
-    const schemaResult = validateBoundedJsonObject(value.dataSchemaJson, `${path29}.dataSchemaJson`);
+    const schemaResult = validateBoundedJsonObject(value.dataSchemaJson, `${path30}.dataSchemaJson`);
     if (schemaResult.ok) dataSchemaJson = schemaResult.value;
     else issues.push(...schemaResult.issues);
   }
-  const sourceJson = value.sourceJson === void 0 ? void 0 : validateSource(value.sourceJson, `${path29}.sourceJson`, issues);
+  const sourceJson = value.sourceJson === void 0 ? void 0 : validateSource(value.sourceJson, `${path30}.sourceJson`, issues);
   if (value.format !== "html_template_v1" || value.templatePath !== "template.html" || value.generatedPreviewPath !== "index.html" || value.dataPath !== "data.json" || !dataJsonResult.ok) {
     return void 0;
   }
@@ -17319,24 +17319,24 @@ function validateDocument(value, path29, issues) {
   if (sourceJson !== void 0) document.sourceJson = sourceJson;
   return document;
 }
-function validatePersistedLiveArtifact(value, path29 = "liveArtifact") {
+function validatePersistedLiveArtifact(value, path30 = "liveArtifact") {
   const issues = [];
-  if (!isPlainObject2(value)) return fail([{ path: path29, message: `${path29} must be an object` }]);
-  if (value.schemaVersion !== 1) issues.push({ path: `${path29}.schemaVersion`, message: `${path29}.schemaVersion must be 1` });
-  const id = asString(value.id, `${path29}.id`, issues, MAX_ID_LENGTH);
-  const projectId = asString(value.projectId, `${path29}.projectId`, issues, MAX_ID_LENGTH);
-  const sessionId = asOptionalString(value.sessionId, `${path29}.sessionId`, issues, MAX_ID_LENGTH);
-  const createdByRunId = asOptionalString(value.createdByRunId, `${path29}.createdByRunId`, issues, MAX_ID_LENGTH);
-  const title = asString(value.title, `${path29}.title`, issues, MAX_TITLE_LENGTH2);
-  const slug = asString(value.slug, `${path29}.slug`, issues, MAX_SLUG_LENGTH);
-  const status = validateEnum(value.status, LIVE_ARTIFACT_STATUSES, `${path29}.status`, issues);
-  const pinned = asBoolean(value.pinned, `${path29}.pinned`, issues);
-  const preview = validatePreview(value.preview, `${path29}.preview`, issues);
-  const refreshStatus = validateEnum(value.refreshStatus, LIVE_ARTIFACT_REFRESH_STATUSES, `${path29}.refreshStatus`, issues);
-  const createdAt = validateIsoDate(value.createdAt, `${path29}.createdAt`, issues);
-  const updatedAt = validateIsoDate(value.updatedAt, `${path29}.updatedAt`, issues);
-  const lastRefreshedAt = value.lastRefreshedAt === void 0 ? void 0 : validateIsoDate(value.lastRefreshedAt, `${path29}.lastRefreshedAt`, issues);
-  const document = validateDocument(value.document, `${path29}.document`, issues);
+  if (!isPlainObject2(value)) return fail([{ path: path30, message: `${path30} must be an object` }]);
+  if (value.schemaVersion !== 1) issues.push({ path: `${path30}.schemaVersion`, message: `${path30}.schemaVersion must be 1` });
+  const id = asString(value.id, `${path30}.id`, issues, MAX_ID_LENGTH);
+  const projectId = asString(value.projectId, `${path30}.projectId`, issues, MAX_ID_LENGTH);
+  const sessionId = asOptionalString(value.sessionId, `${path30}.sessionId`, issues, MAX_ID_LENGTH);
+  const createdByRunId = asOptionalString(value.createdByRunId, `${path30}.createdByRunId`, issues, MAX_ID_LENGTH);
+  const title = asString(value.title, `${path30}.title`, issues, MAX_TITLE_LENGTH2);
+  const slug = asString(value.slug, `${path30}.slug`, issues, MAX_SLUG_LENGTH);
+  const status = validateEnum(value.status, LIVE_ARTIFACT_STATUSES, `${path30}.status`, issues);
+  const pinned = asBoolean(value.pinned, `${path30}.pinned`, issues);
+  const preview = validatePreview(value.preview, `${path30}.preview`, issues);
+  const refreshStatus = validateEnum(value.refreshStatus, LIVE_ARTIFACT_REFRESH_STATUSES, `${path30}.refreshStatus`, issues);
+  const createdAt = validateIsoDate(value.createdAt, `${path30}.createdAt`, issues);
+  const updatedAt = validateIsoDate(value.updatedAt, `${path30}.updatedAt`, issues);
+  const lastRefreshedAt = value.lastRefreshedAt === void 0 ? void 0 : validateIsoDate(value.lastRefreshedAt, `${path30}.lastRefreshedAt`, issues);
+  const document = validateDocument(value.document, `${path30}.document`, issues);
   if (issues.length > 0 || id === void 0 || projectId === void 0 || title === void 0 || slug === void 0 || status === void 0 || pinned === void 0 || preview === void 0 || refreshStatus === void 0 || createdAt === void 0 || updatedAt === void 0 || document === void 0) {
     return fail(issues);
   }
@@ -17359,28 +17359,28 @@ function validatePersistedLiveArtifact(value, path29 = "liveArtifact") {
   if (lastRefreshedAt !== void 0) liveArtifact.lastRefreshedAt = lastRefreshedAt;
   return ok(liveArtifact);
 }
-function validateLiveArtifactRefreshLogEntry(value, path29 = "refreshLogEntry") {
+function validateLiveArtifactRefreshLogEntry(value, path30 = "refreshLogEntry") {
   const issues = [];
-  if (!isPlainObject2(value)) return fail([{ path: path29, message: `${path29} must be an object` }]);
-  if (value.schemaVersion !== 1) issues.push({ path: `${path29}.schemaVersion`, message: `${path29}.schemaVersion must be 1` });
-  const projectId = asString(value.projectId, `${path29}.projectId`, issues, MAX_ID_LENGTH);
-  const artifactId = asString(value.artifactId, `${path29}.artifactId`, issues, MAX_ID_LENGTH);
-  const refreshId = asString(value.refreshId, `${path29}.refreshId`, issues, MAX_ID_LENGTH);
-  const sequence = validateOptionalInteger(value.sequence, `${path29}.sequence`, issues, 0, Number.MAX_SAFE_INTEGER);
-  const step = asString(value.step, `${path29}.step`, issues, MAX_REFRESH_STEP_LENGTH);
-  const status = validateEnum(value.status, REFRESH_STEP_STATUSES, `${path29}.status`, issues);
-  const startedAt = validateIsoDate(value.startedAt, `${path29}.startedAt`, issues);
-  const finishedAt = value.finishedAt === void 0 ? void 0 : validateIsoDate(value.finishedAt, `${path29}.finishedAt`, issues);
-  const durationMs2 = validateOptionalInteger(value.durationMs, `${path29}.durationMs`, issues, 0, Number.MAX_SAFE_INTEGER);
-  const source = value.source === void 0 ? void 0 : validateRefreshSourceMetadata(value.source, `${path29}.source`, issues);
-  const error = value.error === void 0 ? void 0 : validateRefreshErrorRecord(value.error, `${path29}.error`, issues);
+  if (!isPlainObject2(value)) return fail([{ path: path30, message: `${path30} must be an object` }]);
+  if (value.schemaVersion !== 1) issues.push({ path: `${path30}.schemaVersion`, message: `${path30}.schemaVersion must be 1` });
+  const projectId = asString(value.projectId, `${path30}.projectId`, issues, MAX_ID_LENGTH);
+  const artifactId = asString(value.artifactId, `${path30}.artifactId`, issues, MAX_ID_LENGTH);
+  const refreshId = asString(value.refreshId, `${path30}.refreshId`, issues, MAX_ID_LENGTH);
+  const sequence = validateOptionalInteger(value.sequence, `${path30}.sequence`, issues, 0, Number.MAX_SAFE_INTEGER);
+  const step = asString(value.step, `${path30}.step`, issues, MAX_REFRESH_STEP_LENGTH);
+  const status = validateEnum(value.status, REFRESH_STEP_STATUSES, `${path30}.status`, issues);
+  const startedAt = validateIsoDate(value.startedAt, `${path30}.startedAt`, issues);
+  const finishedAt = value.finishedAt === void 0 ? void 0 : validateIsoDate(value.finishedAt, `${path30}.finishedAt`, issues);
+  const durationMs2 = validateOptionalInteger(value.durationMs, `${path30}.durationMs`, issues, 0, Number.MAX_SAFE_INTEGER);
+  const source = value.source === void 0 ? void 0 : validateRefreshSourceMetadata(value.source, `${path30}.source`, issues);
+  const error = value.error === void 0 ? void 0 : validateRefreshErrorRecord(value.error, `${path30}.error`, issues);
   let metadata;
   if (value.metadata !== void 0) {
-    const metadataResult = validateBoundedJsonObject(value.metadata, `${path29}.metadata`);
+    const metadataResult = validateBoundedJsonObject(value.metadata, `${path30}.metadata`);
     if (metadataResult.ok) metadata = metadataResult.value;
     else issues.push(...metadataResult.issues);
   }
-  const createdAt = validateIsoDate(value.createdAt, `${path29}.createdAt`, issues);
+  const createdAt = validateIsoDate(value.createdAt, `${path30}.createdAt`, issues);
   if (issues.length > 0 || projectId === void 0 || artifactId === void 0 || refreshId === void 0 || sequence === void 0 || step === void 0 || status === void 0 || startedAt === void 0 || createdAt === void 0) {
     return fail(issues);
   }
@@ -17402,17 +17402,17 @@ function validateLiveArtifactRefreshLogEntry(value, path29 = "refreshLogEntry")
   if (metadata !== void 0) entry.metadata = metadata;
   return ok(entry);
 }
-function validateLiveArtifactCreateInput(value, path29 = "input") {
+function validateLiveArtifactCreateInput(value, path30 = "input") {
   const issues = [];
-  if (!isPlainObject2(value)) return fail([{ path: path29, message: `${path29} must be an object` }]);
+  if (!isPlainObject2(value)) return fail([{ path: path30, message: `${path30} must be an object` }]);
   validateNoDaemonOwnedFields(value, issues);
-  const title = asString(value.title, `${path29}.title`, issues, MAX_TITLE_LENGTH2);
-  const slug = asOptionalString(value.slug, `${path29}.slug`, issues, MAX_SLUG_LENGTH);
-  const sessionId = asOptionalString(value.sessionId, `${path29}.sessionId`, issues, MAX_ID_LENGTH);
-  const pinned = asOptionalBoolean(value.pinned, `${path29}.pinned`, issues);
-  const status = value.status === void 0 ? void 0 : validateEnum(value.status, LIVE_ARTIFACT_STATUSES, `${path29}.status`, issues);
-  const preview = validatePreview(value.preview, `${path29}.preview`, issues);
-  const document = validateDocument(value.document, `${path29}.document`, issues);
+  const title = asString(value.title, `${path30}.title`, issues, MAX_TITLE_LENGTH2);
+  const slug = asOptionalString(value.slug, `${path30}.slug`, issues, MAX_SLUG_LENGTH);
+  const sessionId = asOptionalString(value.sessionId, `${path30}.sessionId`, issues, MAX_ID_LENGTH);
+  const pinned = asOptionalBoolean(value.pinned, `${path30}.pinned`, issues);
+  const status = value.status === void 0 ? void 0 : validateEnum(value.status, LIVE_ARTIFACT_STATUSES, `${path30}.status`, issues);
+  const preview = validatePreview(value.preview, `${path30}.preview`, issues);
+  const document = validateDocument(value.document, `${path30}.document`, issues);
   if (issues.length > 0 || title === void 0 || preview === void 0 || document === void 0) return fail(issues);
   const input = { title, preview, document };
   if (slug !== void 0) input.slug = slug;
@@ -17421,16 +17421,16 @@ function validateLiveArtifactCreateInput(value, path29 = "input") {
   if (status !== void 0) input.status = status;
   return ok(input);
 }
-function validateLiveArtifactUpdateInput(value, path29 = "input") {
+function validateLiveArtifactUpdateInput(value, path30 = "input") {
   const issues = [];
-  if (!isPlainObject2(value)) return fail([{ path: path29, message: `${path29} must be an object` }]);
+  if (!isPlainObject2(value)) return fail([{ path: path30, message: `${path30} must be an object` }]);
   validateNoDaemonOwnedFields(value, issues);
-  const title = asOptionalString(value.title, `${path29}.title`, issues, MAX_TITLE_LENGTH2);
-  const slug = asOptionalString(value.slug, `${path29}.slug`, issues, MAX_SLUG_LENGTH);
-  const pinned = asOptionalBoolean(value.pinned, `${path29}.pinned`, issues);
-  const status = value.status === void 0 ? void 0 : validateEnum(value.status, LIVE_ARTIFACT_STATUSES, `${path29}.status`, issues);
-  const preview = value.preview === void 0 ? void 0 : validatePreview(value.preview, `${path29}.preview`, issues);
-  const document = value.document === void 0 ? void 0 : validateDocument(value.document, `${path29}.document`, issues);
+  const title = asOptionalString(value.title, `${path30}.title`, issues, MAX_TITLE_LENGTH2);
+  const slug = asOptionalString(value.slug, `${path30}.slug`, issues, MAX_SLUG_LENGTH);
+  const pinned = asOptionalBoolean(value.pinned, `${path30}.pinned`, issues);
+  const status = value.status === void 0 ? void 0 : validateEnum(value.status, LIVE_ARTIFACT_STATUSES, `${path30}.status`, issues);
+  const preview = value.preview === void 0 ? void 0 : validatePreview(value.preview, `${path30}.preview`, issues);
+  const document = value.document === void 0 ? void 0 : validateDocument(value.document, `${path30}.document`, issues);
   if (issues.length > 0) return fail(issues);
   const input = {};
   if (title !== void 0) input.title = title;
@@ -17464,9 +17464,9 @@ var LiveArtifactRefreshAbortError = class extends Error {
     if (options.step !== void 0) this.step = options.step;
   }
 };
-function validateTimeoutMs(value, path29) {
+function validateTimeoutMs(value, path30) {
   if (!Number.isSafeInteger(value) || value < 1) {
-    throw new RangeError(`${path29} must be a positive safe integer`);
+    throw new RangeError(`${path30} must be a positive safe integer`);
   }
   return value;
 }
@@ -17589,8 +17589,8 @@ function asBoundedRefreshOutput(value) {
 }
 var SAFE_MAPPING_SEGMENT2 = /^[A-Za-z_][A-Za-z0-9_-]*$|^(?:0|[1-9][0-9]*)$/;
 var UNSAFE_MAPPING_SEGMENTS2 = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
-function parseMappingPath(path29, field) {
-  const normalized = path29.startsWith("$.") ? path29.slice(2) : path29;
+function parseMappingPath(path30, field) {
+  const normalized = path30.startsWith("$.") ? path30.slice(2) : path30;
   if (normalized.length === 0 || normalized.startsWith(".") || normalized.endsWith(".") || normalized.includes("..")) {
     throw new Error(`${field} must be a dot-separated JSON path`);
   }
@@ -17605,9 +17605,9 @@ function parseMappingPath(path29, field) {
 function isJsonObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function readMappedValue(root, path29) {
+function readMappedValue(root, path30) {
   let current = root;
-  for (const segment of parseMappingPath(path29, "outputMapping.dataPaths.from")) {
+  for (const segment of parseMappingPath(path30, "outputMapping.dataPaths.from")) {
     if (Array.isArray(current)) {
       const index = Number(segment);
       if (!Number.isSafeInteger(index) || index < 0) throw new Error(`outputMapping.dataPaths.from array segment is invalid: ${segment}`);
@@ -17624,8 +17624,8 @@ function readMappedValue(root, path29) {
 function makeContainer(nextSegment) {
   return /^(?:0|[1-9][0-9]*)$/.test(nextSegment) ? [] : {};
 }
-function writeMappedValue(root, path29, value) {
-  const segments = parseMappingPath(path29, "outputMapping.dataPaths.to");
+function writeMappedValue(root, path30, value) {
+  const segments = parseMappingPath(path30, "outputMapping.dataPaths.to");
   let current = root;
   for (let index = 0; index < segments.length; index += 1) {
     const segment = segments[index];
@@ -18215,8 +18215,8 @@ function toSummary(artifact) {
     hasDocument: _document !== void 0
   };
 }
-function validationError(path29, message) {
-  return new LiveArtifactStoreValidationError(message, [{ path: path29, message }]);
+function validationError(path30, message) {
+  return new LiveArtifactStoreValidationError(message, [{ path: path30, message }]);
 }
 function toIsoDate(value) {
   return value instanceof Date ? value.toISOString() : value;
@@ -20447,8 +20447,8 @@ var ComposioConnectorProvider = class {
       }
     };
   }
-  async requestJson(path29, input) {
-    const response = await this.request(path29, input);
+  async requestJson(path30, input) {
+    const response = await this.request(path30, input);
     if (!response.ok) {
       const message = await getComposioErrorMessage(response);
       throw new ConnectorServiceError("CONNECTOR_EXECUTION_FAILED", message ?? `Composio request failed with HTTP ${response.status}`, response.status === 401 ? 401 : 502, { httpStatus: response.status });
@@ -20459,14 +20459,14 @@ var ComposioConnectorProvider = class {
     }
     return value;
   }
-  async request(path29, input) {
+  async request(path30, input) {
     const apiKey = this.getApiKey();
     if (!apiKey) {
       throw new ConnectorServiceError("CONNECTOR_EXECUTION_FAILED", "Composio provider is not configured", 503, { setting: "apiKey" });
     }
     const timeout = AbortSignal.timeout(DEFAULT_COMPOSIO_TIMEOUT_MS);
     const signal = input.signal ? AbortSignal.any([input.signal, timeout]) : timeout;
-    return fetch(`${this.getBaseUrl().replace(/\/+$/, "")}${path29}`, {
+    return fetch(`${this.getBaseUrl().replace(/\/+$/, "")}${path30}`, {
       method: input.method,
       headers: {
         accept: "application/json",
@@ -20779,45 +20779,45 @@ function runtimeSafetyForTool(tool) {
   if (classified.sideEffect !== "read" || classified.approval !== "auto") return classified;
   return tool.safety;
 }
-function assertJsonSchemaMatches(value, schema, path29 = "input") {
+function assertJsonSchemaMatches(value, schema, path30 = "input") {
   if (schema === void 0) return;
   const type = schema.type;
   if (typeof type === "string") {
     const actualType = Array.isArray(value) ? "array" : value === null ? "null" : typeof value;
     if (type === "number") {
-      if (typeof value !== "number") throw new Error(`${path29} must be a number`);
+      if (typeof value !== "number") throw new Error(`${path30} must be a number`);
     } else if (type === "integer") {
-      if (typeof value !== "number" || !Number.isInteger(value)) throw new Error(`${path29} must be an integer`);
+      if (typeof value !== "number" || !Number.isInteger(value)) throw new Error(`${path30} must be an integer`);
     } else if (type !== actualType) {
-      throw new Error(`${path29} must be a ${type}`);
+      throw new Error(`${path30} must be a ${type}`);
     }
   }
   if (type === "object") {
-    if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`${path29} must be an object`);
+    if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`${path30} must be an object`);
     const objectValue = value;
     const required = Array.isArray(schema.required) ? schema.required.filter((item) => typeof item === "string") : [];
     for (const key of required) {
-      if (objectValue[key] === void 0) throw new Error(`${path29}.${key} is required by connector input schema`);
+      if (objectValue[key] === void 0) throw new Error(`${path30}.${key} is required by connector input schema`);
     }
     const properties = schema.properties;
     const propertySchemas = properties !== null && typeof properties === "object" && !Array.isArray(properties) ? properties : {};
     if (schema.additionalProperties === false) {
       for (const key of Object.keys(objectValue)) {
-        if (propertySchemas[key] === void 0) throw new Error(`${path29}.${key} is not allowed by connector input schema`);
+        if (propertySchemas[key] === void 0) throw new Error(`${path30}.${key} is not allowed by connector input schema`);
       }
     }
     for (const [key, childSchema] of Object.entries(propertySchemas)) {
       if (objectValue[key] !== void 0 && childSchema !== null && typeof childSchema === "object" && !Array.isArray(childSchema)) {
-        assertJsonSchemaMatches(objectValue[key], childSchema, `${path29}.${key}`);
+        assertJsonSchemaMatches(objectValue[key], childSchema, `${path30}.${key}`);
       }
     }
   }
   if (type === "string" && typeof value === "string") {
-    if (typeof schema.maxLength === "number" && value.length > schema.maxLength) throw new Error(`${path29} exceeds connector input schema maxLength`);
+    if (typeof schema.maxLength === "number" && value.length > schema.maxLength) throw new Error(`${path30} exceeds connector input schema maxLength`);
   }
   if ((type === "number" || type === "integer") && typeof value === "number") {
-    if (typeof schema.minimum === "number" && value < schema.minimum) throw new Error(`${path29} is below connector input schema minimum`);
-    if (typeof schema.maximum === "number" && value > schema.maximum) throw new Error(`${path29} exceeds connector input schema maximum`);
+    if (typeof schema.minimum === "number" && value < schema.minimum) throw new Error(`${path30} is below connector input schema minimum`);
+    if (typeof schema.maximum === "number" && value > schema.maximum) throw new Error(`${path30} exceeds connector input schema maximum`);
   }
 }
 function defaultConnectedAccountLabel(definition) {
@@ -22717,24 +22717,52 @@ function safeVercelProjectName(raw) {
   return String(raw).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || `od-${randomUUID4().slice(0, 8)}`;
 }
 
+// apps/daemon/src/layout.ts
+import fs7 from "node:fs";
+import path28 from "node:path";
+var REPO_DATA_DIR = ".od";
+var PACKAGE_DATA_DIR = ".tfdesign";
+function detectLayout(moduleDir) {
+  const base = path28.basename(moduleDir);
+  const daemonDir = base === "dist" || base === "src" ? path28.dirname(moduleDir) : moduleDir;
+  const candidate = path28.resolve(daemonDir, "../..");
+  const repo = fs7.existsSync(path28.join(candidate, "pnpm-workspace.yaml")) && fs7.existsSync(path28.join(candidate, "apps", "daemon"));
+  return repo ? { root: candidate, repo: true } : { root: daemonDir, repo: false };
+}
+function defaultDataRoot(moduleDir, cwd = process.cwd()) {
+  const layout = detectLayout(moduleDir);
+  return path28.join(
+    layout.repo ? layout.root : cwd,
+    layout.repo ? REPO_DATA_DIR : PACKAGE_DATA_DIR
+  );
+}
+function expandDataRoot(raw, cwd = process.cwd()) {
+  if (raw.startsWith("~/"))
+    return path28.join(process.env.HOME ?? "~", raw.slice(2));
+  return path28.isAbsolute(raw) ? raw : path28.resolve(cwd, raw);
+}
+function resolveDataRoot(moduleDir, cwd = process.cwd()) {
+  const raw = process.env.TFDESIGN_DATA_DIR || process.env.OD_DATA_DIR;
+  return raw ? expandDataRoot(raw, cwd) : defaultDataRoot(moduleDir, cwd);
+}
+
 // apps/daemon/src/server.ts
 var __filename = fileURLToPath2(import.meta.url);
-var __dirname = path28.dirname(__filename);
+var __dirname = path29.dirname(__filename);
 var require2 = createRequire(import.meta.url);
 function resolveProjectRoot(moduleDir) {
-  const base = path28.basename(moduleDir);
-  const daemonDir = base === "dist" || base === "src" ? path28.dirname(moduleDir) : moduleDir;
-  return path28.resolve(daemonDir, "../..");
+  return detectLayout(moduleDir).root;
 }
 function resolveDaemonCliPath() {
   try {
     const packageJsonPath = require2.resolve("@open-design/daemon/package.json");
-    return path28.join(path28.dirname(packageJsonPath), "dist", "cli.js");
+    return path29.join(path29.dirname(packageJsonPath), "dist", "cli.js");
   } catch {
-    return path28.join(__dirname, "cli.js");
+    return path29.join(__dirname, "cli.js");
   }
 }
-var PROJECT_ROOT = resolveProjectRoot(__dirname);
+var LAYOUT = detectLayout(__dirname);
+var PROJECT_ROOT = LAYOUT.root;
 var RESOURCE_ROOT_ENV = "OD_RESOURCE_ROOT";
 function buildDeckWorkflowReminder(message, metadata) {
   if (!message || typeof message !== "string") return "";
@@ -22773,9 +22801,9 @@ function composeLiveInstructionPrompt({
 }
 function resolveCodexGeneratedImagesDir(agentId, metadata, env = process.env, homeDir = os4.homedir()) {
   if (!shouldRenderCodexImagegenOverride(agentId, metadata)) return null;
-  const rawCodexHome = typeof env?.CODEX_HOME === "string" && env.CODEX_HOME.trim().length > 0 ? env.CODEX_HOME.trim() : path28.join(homeDir, ".codex");
-  const codexHome = rawCodexHome.startsWith("~/") ? path28.join(homeDir, rawCodexHome.slice(2)) : rawCodexHome;
-  return path28.resolve(codexHome, "generated_images");
+  const rawCodexHome = typeof env?.CODEX_HOME === "string" && env.CODEX_HOME.trim().length > 0 ? env.CODEX_HOME.trim() : path29.join(homeDir, ".codex");
+  const codexHome = rawCodexHome.startsWith("~/") ? path29.join(homeDir, rawCodexHome.slice(2)) : rawCodexHome;
+  return path29.resolve(codexHome, "generated_images");
 }
 function isMissingPathError(err) {
   return err && typeof err === "object" && "code" in err && err.code === "ENOENT";
@@ -22787,7 +22815,7 @@ function collectProtectedDirRoots(protectedDirs, {
   const roots = [];
   for (const raw of Array.isArray(protectedDirs) ? protectedDirs : []) {
     if (typeof raw !== "string" || raw.trim().length === 0) continue;
-    const resolved = path28.resolve(raw);
+    const resolved = path29.resolve(raw);
     roots.push(resolved);
     try {
       const canonical = realpathSync2(resolved);
@@ -22806,16 +22834,16 @@ function findContainingProtectedRoot(candidate, protectedRoots) {
 }
 function validateCodexGeneratedImagesDir(codexGeneratedImagesDir, {
   protectedDirs = [],
-  mkdirSync: mkdirSync2 = fs7.mkdirSync,
-  lstatSync = fs7.lstatSync,
-  statSync: statSync3 = fs7.statSync,
-  realpathSync: realpathSync2 = fs7.realpathSync.native,
+  mkdirSync: mkdirSync2 = fs8.mkdirSync,
+  lstatSync = fs8.lstatSync,
+  statSync: statSync3 = fs8.statSync,
+  realpathSync: realpathSync2 = fs8.realpathSync.native,
   warn = console.warn
 } = {}) {
   if (typeof codexGeneratedImagesDir !== "string" || codexGeneratedImagesDir.trim().length === 0) {
     return null;
   }
-  const resolved = path28.resolve(codexGeneratedImagesDir);
+  const resolved = path29.resolve(codexGeneratedImagesDir);
   const protectedRoots = collectProtectedDirRoots(protectedDirs, {
     realpathSync: realpathSync2,
     statSync: statSync3
@@ -22841,7 +22869,7 @@ function validateCodexGeneratedImagesDir(codexGeneratedImagesDir, {
       warnSkipped(`${resolved} is not a directory`);
       return null;
     }
-    const parent = path28.dirname(resolved);
+    const parent = path29.dirname(resolved);
     const protectedParentRoot = findContainingProtectedRoot(
       parent,
       protectedRoots
@@ -22852,9 +22880,9 @@ function validateCodexGeneratedImagesDir(codexGeneratedImagesDir, {
     }
     mkdirSync2(parent, { recursive: true });
     const canonicalParent = realpathSync2(parent);
-    const canonicalCandidate = path28.join(
+    const canonicalCandidate = path29.join(
       canonicalParent,
-      path28.basename(resolved)
+      path29.basename(resolved)
     );
     const protectedCanonicalParentRoot = findContainingProtectedRoot(
       canonicalCandidate,
@@ -22898,13 +22926,10 @@ function resolveChatExtraAllowedDirs({
   brandGuidelinesDir,
   linkedDirs = [],
   codexGeneratedImagesDir,
-  existsSync: existsSync3 = fs7.existsSync
+  existsSync: existsSync3 = fs8.existsSync
 }) {
   const isCodex = typeof agentId === "string" && agentId.trim().toLowerCase() === "codex";
-  const candidates = isCodex ? [codexGeneratedImagesDir] : [
-    brandGuidelinesDir,
-    ...Array.isArray(linkedDirs) ? linkedDirs : []
-  ];
+  const candidates = isCodex ? [codexGeneratedImagesDir] : [brandGuidelinesDir, ...Array.isArray(linkedDirs) ? linkedDirs : []];
   return Array.from(
     new Set(
       candidates.filter(
@@ -23032,27 +23057,27 @@ function formatAttachmentPosition(position) {
   return `x=${position.x}, y=${position.y}, width=${position.width}, height=${position.height}`;
 }
 function isPathWithin(base, target) {
-  const relativePath = path28.relative(path28.resolve(base), path28.resolve(target));
-  return relativePath === "" || relativePath.length > 0 && !relativePath.startsWith("..") && !path28.isAbsolute(relativePath);
+  const relativePath = path29.relative(path29.resolve(base), path29.resolve(target));
+  return relativePath === "" || relativePath.length > 0 && !relativePath.startsWith("..") && !path29.isAbsolute(relativePath);
 }
 function resolveProcessResourcesPath() {
   if (typeof process.resourcesPath === "string" && process.resourcesPath.length > 0) {
     return process.resourcesPath;
   }
-  const resourcesMarker = `${path28.sep}Contents${path28.sep}Resources${path28.sep}`;
+  const resourcesMarker = `${path29.sep}Contents${path29.sep}Resources${path29.sep}`;
   const markerIndex = process.execPath.indexOf(resourcesMarker);
   if (markerIndex !== -1) {
     return process.execPath.slice(0, markerIndex + resourcesMarker.length - 1);
   }
   const normalizedExecPath = process.execPath.toLowerCase();
-  const windowsResourceBinMarker = `${path28.sep}resources${path28.sep}open-design${path28.sep}bin${path28.sep}`.toLowerCase();
+  const windowsResourceBinMarker = `${path29.sep}resources${path29.sep}open-design${path29.sep}bin${path29.sep}`.toLowerCase();
   const windowsMarkerIndex = normalizedExecPath.indexOf(
     windowsResourceBinMarker
   );
   if (windowsMarkerIndex !== -1) {
     return process.execPath.slice(
       0,
-      windowsMarkerIndex + `${path28.sep}resources`.length
+      windowsMarkerIndex + `${path29.sep}resources`.length
     );
   }
   return null;
@@ -23062,8 +23087,8 @@ function resolveDaemonResourceRoot({
   safeBases = [PROJECT_ROOT, resolveProcessResourcesPath()]
 } = {}) {
   if (!configured || configured.length === 0) return null;
-  const resolved = path28.resolve(configured);
-  const normalizedSafeBases = safeBases.filter((base) => typeof base === "string" && base.length > 0).map((base) => path28.resolve(base));
+  const resolved = path29.resolve(configured);
+  const normalizedSafeBases = safeBases.filter((base) => typeof base === "string" && base.length > 0).map((base) => path29.resolve(base));
   if (!normalizedSafeBases.some((base) => isPathWithin(base, resolved))) {
     throw new Error(
       `${RESOURCE_ROOT_ENV} must be under the workspace root or app resources path`
@@ -23072,78 +23097,84 @@ function resolveDaemonResourceRoot({
   return resolved;
 }
 function resolveDaemonResourceDir(resourceRoot, segment, fallback) {
-  return resourceRoot ? path28.join(resourceRoot, segment) : fallback;
+  return resourceRoot ? path29.join(resourceRoot, segment) : fallback;
 }
 var DAEMON_RESOURCE_ROOT = resolveDaemonResourceRoot();
-var STATIC_DIR = path28.join(PROJECT_ROOT, "apps", "web", "out");
+var STATIC_DIR = path29.join(PROJECT_ROOT, "apps", "web", "out");
 var OD_BIN = resolveDaemonCliPath();
 var OD_NODE_BIN = process.execPath;
 var BRAND_GUIDELINES_DIR = resolveDaemonResourceDir(
   DAEMON_RESOURCE_ROOT,
   "brand-guidelines",
-  path28.join(PROJECT_ROOT, "brand-guidelines")
+  path29.join(PROJECT_ROOT, "brand-guidelines")
 );
 var CRAFT_DIR = resolveDaemonResourceDir(
   DAEMON_RESOURCE_ROOT,
   "craft",
-  path28.join(PROJECT_ROOT, "craft")
+  path29.join(PROJECT_ROOT, "craft")
 );
 var FRAMES_DIR = resolveDaemonResourceDir(
   DAEMON_RESOURCE_ROOT,
   "frames",
-  path28.join(PROJECT_ROOT, "assets", "frames")
+  path29.join(PROJECT_ROOT, "assets", "frames")
 );
 var BUNDLED_PETS_DIR = resolveDaemonResourceDir(
   DAEMON_RESOURCE_ROOT,
   "community-pets",
-  path28.join(PROJECT_ROOT, "assets", "community-pets")
+  path29.join(PROJECT_ROOT, "assets", "community-pets")
 );
 var PROMPT_TEMPLATES_DIR = resolveDaemonResourceDir(
   DAEMON_RESOURCE_ROOT,
   "prompt-templates",
-  path28.join(PROJECT_ROOT, "prompt-templates")
+  path29.join(PROJECT_ROOT, "prompt-templates")
 );
 var PROMPT_TEMPLATE_ASSETS_DIR = resolveDaemonResourceDir(
   DAEMON_RESOURCE_ROOT,
-  path28.join("assets", "prompt-templates"),
-  path28.join(PROJECT_ROOT, "assets", "prompt-templates")
+  path29.join("assets", "prompt-templates"),
+  path29.join(PROJECT_ROOT, "assets", "prompt-templates")
 );
 function resolveDataDir(raw, projectRoot) {
-  if (!raw) return path28.join(projectRoot, ".od");
-  const expanded = raw.startsWith("~/") ? path28.join(os4.homedir(), raw.slice(2)) : raw;
-  const resolved = path28.isAbsolute(expanded) ? expanded : path28.resolve(projectRoot, expanded);
+  if (!raw) return path29.join(projectRoot, ".od");
+  const expanded = raw.startsWith("~/") ? path29.join(os4.homedir(), raw.slice(2)) : raw;
+  const resolved = path29.isAbsolute(expanded) ? expanded : path29.resolve(projectRoot, expanded);
   try {
-    fs7.mkdirSync(resolved, { recursive: true });
-    fs7.accessSync(resolved, fs7.constants.W_OK);
+    fs8.mkdirSync(resolved, { recursive: true });
+    fs8.accessSync(resolved, fs8.constants.W_OK);
   } catch (err) {
     const e = err;
     throw new Error(`OD_DATA_DIR "${resolved}" is not writable: ${e.message}`);
   }
   return resolved;
 }
-var RUNTIME_DATA_DIR = resolveDataDir(process.env.OD_DATA_DIR, PROJECT_ROOT);
-var ARTIFACTS_DIR = path28.join(RUNTIME_DATA_DIR, "artifacts");
-var DEFAULT_PROJECTS_DIR = path28.join(RUNTIME_DATA_DIR, "projects");
-var USER_PROMPT_TEMPLATES_DIR = path28.join(
+var RUNTIME_DATA_DIR = resolveDataDir(
+  process.env.TFDESIGN_DATA_DIR || process.env.OD_DATA_DIR || defaultDataRoot(__dirname),
+  PROJECT_ROOT
+);
+function dataRoot() {
+  return RUNTIME_DATA_DIR;
+}
+var ARTIFACTS_DIR = path29.join(RUNTIME_DATA_DIR, "artifacts");
+var DEFAULT_PROJECTS_DIR = path29.join(RUNTIME_DATA_DIR, "projects");
+var USER_PROMPT_TEMPLATES_DIR = path29.join(
   RUNTIME_DATA_DIR,
   "prompt-templates"
 );
-var USER_BRAND_GUIDELINES_DIR = path28.join(
+var USER_BRAND_GUIDELINES_DIR = path29.join(
   RUNTIME_DATA_DIR,
   "brand-guidelines"
 );
-var BRAND_ASSETS_DIR = path28.join(RUNTIME_DATA_DIR, "brand-assets");
-fs7.mkdirSync(BRAND_ASSETS_DIR, { recursive: true });
+var BRAND_ASSETS_DIR = path29.join(RUNTIME_DATA_DIR, "brand-assets");
+fs8.mkdirSync(BRAND_ASSETS_DIR, { recursive: true });
 function resolveProjectsDir(dataDir) {
-  const overrideFile = path28.join(dataDir, "projects-dir.json");
+  const overrideFile = path29.join(dataDir, "projects-dir.json");
   try {
-    const raw = fs7.readFileSync(overrideFile, "utf8");
+    const raw = fs8.readFileSync(overrideFile, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed.projectsDir === "string" && parsed.projectsDir.trim()) {
-      const expanded = parsed.projectsDir.startsWith("~/") ? path28.join(os4.homedir(), parsed.projectsDir.slice(2)) : parsed.projectsDir;
-      const resolved = path28.isAbsolute(expanded) ? expanded : path28.resolve(dataDir, expanded);
-      fs7.mkdirSync(resolved, { recursive: true });
-      fs7.accessSync(resolved, fs7.constants.W_OK);
+      const expanded = parsed.projectsDir.startsWith("~/") ? path29.join(os4.homedir(), parsed.projectsDir.slice(2)) : parsed.projectsDir;
+      const resolved = path29.isAbsolute(expanded) ? expanded : path29.resolve(dataDir, expanded);
+      fs8.mkdirSync(resolved, { recursive: true });
+      fs8.accessSync(resolved, fs8.constants.W_OK);
       return resolved;
     }
   } catch {
@@ -23151,11 +23182,14 @@ function resolveProjectsDir(dataDir) {
   return DEFAULT_PROJECTS_DIR;
 }
 var PROJECTS_DIR = resolveProjectsDir(RUNTIME_DATA_DIR);
-fs7.mkdirSync(PROJECTS_DIR, { recursive: true });
-var PROJECTS_DIR_OVERRIDE_FILE = path28.join(RUNTIME_DATA_DIR, "projects-dir.json");
-if (!fs7.existsSync(PROJECTS_DIR_OVERRIDE_FILE) && process.env.OD_FORCE_STORAGE_UNCONFIGURED !== "1") {
+fs8.mkdirSync(PROJECTS_DIR, { recursive: true });
+var PROJECTS_DIR_OVERRIDE_FILE = path29.join(
+  RUNTIME_DATA_DIR,
+  "projects-dir.json"
+);
+if (!fs8.existsSync(PROJECTS_DIR_OVERRIDE_FILE) && process.env.OD_FORCE_STORAGE_UNCONFIGURED !== "1") {
   try {
-    fs7.writeFileSync(
+    fs8.writeFileSync(
       PROJECTS_DIR_OVERRIDE_FILE,
       JSON.stringify({ projectsDir: DEFAULT_PROJECTS_DIR }, null, 2),
       "utf8"
@@ -23518,9 +23552,9 @@ function openNativeFolderDialog() {
 function createSseErrorPayload(code, message, init = {}) {
   return { message, error: createCompatApiError(code, message, init) };
 }
-var UPLOAD_DIR = path28.join(os4.tmpdir(), "od-uploads");
-fs7.mkdirSync(UPLOAD_DIR, { recursive: true });
-fs7.mkdirSync(ARTIFACTS_DIR, { recursive: true });
+var UPLOAD_DIR = path29.join(os4.tmpdir(), "od-uploads");
+fs8.mkdirSync(UPLOAD_DIR, { recursive: true });
+fs8.mkdirSync(ARTIFACTS_DIR, { recursive: true });
 var upload = multer({
   storage: multer.diskStorage({
     destination: UPLOAD_DIR,
@@ -23555,7 +23589,10 @@ var brandAssetUpload = multer({
     filename: (_req, file, cb) => {
       file.originalname = decodeMultipartFilename(file.originalname);
       const safe = sanitizeName(file.originalname);
-      cb(null, `${Date.now()}-${Math.random().toString(36).slice(2, 8)}-${safe}`);
+      cb(
+        null,
+        `${Date.now()}-${Math.random().toString(36).slice(2, 8)}-${safe}`
+      );
     }
   }),
   limits: { fileSize: 20 * 1024 * 1024 }
@@ -23792,12 +23829,16 @@ async function startServer({
   } catch (error) {
     console.warn("[od] Failed to reconcile projects from disk:", error);
   }
-  if (fs7.existsSync(STATIC_DIR)) {
+  if (fs8.existsSync(STATIC_DIR)) {
     app.use(express.static(STATIC_DIR));
   }
   app.get("/api/health", async (_req, res) => {
     const versionInfo = await readCurrentAppVersionInfo();
-    res.json({ ok: true, version: versionInfo.version });
+    res.json({
+      ok: true,
+      version: versionInfo.version,
+      dataRoot: RUNTIME_DATA_DIR
+    });
   });
   app.get("/api/version", async (_req, res) => {
     const version = await readCurrentAppVersionInfo();
@@ -23894,8 +23935,8 @@ async function startServer({
     } catch (err) {
       return sendApiError(res, 500, "CLI_RESOLVE_FAILED", String(err));
     }
-    const cliExists = fs7.existsSync(cliPath);
-    const nodeExists = fs7.existsSync(process.execPath);
+    const cliExists = fs8.existsSync(cliPath);
+    const nodeExists = fs8.existsSync(process.execPath);
     const hints = [];
     if (!cliExists) {
       hints.push(
@@ -24173,7 +24214,7 @@ async function startServer({
           return res.status(400).json({ error: "zip file required" });
         const originalName = req.file.originalname || "Claude Design export.zip";
         if (!/\.zip$/i.test(originalName)) {
-          fs7.promises.unlink(req.file.path).catch(() => {
+          fs8.promises.unlink(req.file.path).catch(() => {
           });
           return res.status(400).json({ error: "expected a .zip file" });
         }
@@ -24184,7 +24225,7 @@ async function startServer({
           req.file.path,
           projectDir(PROJECTS_DIR, id)
         );
-        fs7.promises.unlink(req.file.path).catch(() => {
+        fs8.promises.unlink(req.file.path).catch(() => {
         });
         const project = insertProject(db, {
           id,
@@ -24216,7 +24257,7 @@ async function startServer({
           files: imported.files
         });
       } catch (err) {
-        if (req.file?.path) fs7.promises.unlink(req.file.path).catch(() => {
+        if (req.file?.path) fs8.promises.unlink(req.file.path).catch(() => {
         });
         res.status(400).json({ error: String(err) });
       }
@@ -24225,7 +24266,7 @@ async function startServer({
   app.post("/api/import/folder", async (req, res) => {
     try {
       const folderPath = typeof req.body?.folderPath === "string" ? req.body.folderPath : "";
-      if (!folderPath || !path28.isAbsolute(path28.normalize(folderPath))) {
+      if (!folderPath || !path29.isAbsolute(path29.normalize(folderPath))) {
         return res.status(400).json({ error: "an absolute folderPath is required" });
       }
       const validated = validateProjectBaseDir(folderPath, {
@@ -24236,7 +24277,7 @@ async function startServer({
         return res.status(400).json({ error: validated.error });
       }
       const realSource = validated.baseDir;
-      if (PROJECTS_DIR && realSource.startsWith(PROJECTS_DIR + path28.sep)) {
+      if (PROJECTS_DIR && realSource.startsWith(PROJECTS_DIR + path29.sep)) {
         reconcileProjectsFromDisk(db, PROJECTS_DIR);
       }
       const existing = findProjectByDir(db, realSource, PROJECTS_DIR);
@@ -24272,7 +24313,7 @@ async function startServer({
       });
       const id = randomId();
       const now = Date.now();
-      const baseName = path28.basename(realSource) || "Imported folder";
+      const baseName = path29.basename(realSource) || "Imported folder";
       const project = insertProject(db, {
         id,
         name: baseName,
@@ -24731,7 +24772,10 @@ async function startServer({
   });
   app.get("/api/brand-guidelines", async (_req, res) => {
     try {
-      const systems = await listBrandGuidelines(BRAND_GUIDELINES_DIR, USER_BRAND_GUIDELINES_DIR);
+      const systems = await listBrandGuidelines(
+        BRAND_GUIDELINES_DIR,
+        USER_BRAND_GUIDELINES_DIR
+      );
       res.json({
         brandGuidelines: systems.map(({ body, ...rest }) => rest)
       });
@@ -24741,7 +24785,11 @@ async function startServer({
   });
   app.get("/api/brand-guidelines/:id", async (req, res) => {
     try {
-      const body = await readBrandGuideline(BRAND_GUIDELINES_DIR, USER_BRAND_GUIDELINES_DIR, req.params.id);
+      const body = await readBrandGuideline(
+        BRAND_GUIDELINES_DIR,
+        USER_BRAND_GUIDELINES_DIR,
+        req.params.id
+      );
       if (body === null)
         return res.status(404).json({ error: "brand guideline not found" });
       res.json({ id: req.params.id, body });
@@ -24751,7 +24799,11 @@ async function startServer({
   });
   app.get("/api/brand-guidelines/:id/preview", async (req, res) => {
     try {
-      const body = await readBrandGuideline(BRAND_GUIDELINES_DIR, USER_BRAND_GUIDELINES_DIR, req.params.id);
+      const body = await readBrandGuideline(
+        BRAND_GUIDELINES_DIR,
+        USER_BRAND_GUIDELINES_DIR,
+        req.params.id
+      );
       if (body === null)
         return res.status(404).type("text/plain").send("not found");
       const html = renderBrandGuidelinePreview(req.params.id, body);
@@ -24762,7 +24814,11 @@ async function startServer({
   });
   app.get("/api/brand-guidelines/:id/showcase", async (req, res) => {
     try {
-      const body = await readBrandGuideline(BRAND_GUIDELINES_DIR, USER_BRAND_GUIDELINES_DIR, req.params.id);
+      const body = await readBrandGuideline(
+        BRAND_GUIDELINES_DIR,
+        USER_BRAND_GUIDELINES_DIR,
+        req.params.id
+      );
       if (body === null)
         return res.status(404).type("text/plain").send("not found");
       const html = renderBrandGuidelineShowcase(req.params.id, body);
@@ -24773,7 +24829,10 @@ async function startServer({
   });
   app.post("/api/brand-guidelines", async (req, res) => {
     try {
-      const created = await createUserBrandGuideline(USER_BRAND_GUIDELINES_DIR, req.body ?? {});
+      const created = await createUserBrandGuideline(
+        USER_BRAND_GUIDELINES_DIR,
+        req.body ?? {}
+      );
       res.status(201).json({ brandGuideline: created });
     } catch (err) {
       res.status(500).json({ error: String(err) });
@@ -24786,7 +24845,8 @@ async function startServer({
         req.params.id,
         req.body ?? {}
       );
-      if (!updated) return res.status(404).json({ error: "brand guideline not found" });
+      if (!updated)
+        return res.status(404).json({ error: "brand guideline not found" });
       res.json({ brandGuideline: updated });
     } catch (err) {
       res.status(500).json({ error: String(err) });
@@ -24794,8 +24854,12 @@ async function startServer({
   });
   app.delete("/api/brand-guidelines/:id", async (req, res) => {
     try {
-      const removed = await deleteUserBrandGuideline(USER_BRAND_GUIDELINES_DIR, req.params.id);
-      if (!removed) return res.status(404).json({ error: "brand guideline not found" });
+      const removed = await deleteUserBrandGuideline(
+        USER_BRAND_GUIDELINES_DIR,
+        req.params.id
+      );
+      if (!removed)
+        return res.status(404).json({ error: "brand guideline not found" });
       res.json({ ok: true });
     } catch (err) {
       res.status(500).json({ error: String(err) });
@@ -24821,7 +24885,9 @@ async function startServer({
       res.json(result);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      const status = /non-public|blocked|unsupported protocol|invalid url|not html|too many redirects|fetch failed/i.test(message) ? 422 : 500;
+      const status = /non-public|blocked|unsupported protocol|invalid url|not html|too many redirects|fetch failed/i.test(
+        message
+      ) ? 422 : 500;
       res.status(status).json({ error: message });
     }
   });
@@ -24830,7 +24896,8 @@ async function startServer({
       const repo = typeof req.body?.repo === "string" ? req.body.repo.trim() : "";
       const url = typeof req.body?.url === "string" ? req.body.url.trim() : "";
       const target = repo || url;
-      if (!target) return res.status(400).json({ error: "repo or url is required" });
+      if (!target)
+        return res.status(400).json({ error: "repo or url is required" });
       const { id } = startGithubExtractionJob(target);
       res.status(202).json({ runId: id, status: "running" });
     } catch (err) {
@@ -24847,19 +24914,30 @@ async function startServer({
       const body = typeof req.body?.body === "string" ? req.body.body : "";
       const instruction = typeof req.body?.instruction === "string" ? req.body.instruction : "";
       const history = Array.isArray(req.body?.history) ? req.body.history.filter((h) => typeof h === "string") : [];
-      if (!body.trim()) return res.status(400).json({ error: "body is required" });
-      if (!instruction.trim()) return res.status(400).json({ error: "instruction is required" });
+      if (!body.trim())
+        return res.status(400).json({ error: "body is required" });
+      if (!instruction.trim())
+        return res.status(400).json({ error: "instruction is required" });
       const refined = await refineDesignMd(body, instruction, history);
       res.json({ body: refined });
     } catch (err) {
       res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
     }
   });
-  app.post("/api/brand-guidelines/upload-image", brandAssetUpload.single("image"), (req, res) => {
-    const file = req.file;
-    if (!file) return res.status(400).json({ error: "image file is required" });
-    res.json({ url: `/brand-assets/${file.filename}`, name: file.originalname, size: file.size });
-  });
+  app.post(
+    "/api/brand-guidelines/upload-image",
+    brandAssetUpload.single("image"),
+    (req, res) => {
+      const file = req.file;
+      if (!file)
+        return res.status(400).json({ error: "image file is required" });
+      res.json({
+        url: `/brand-assets/${file.filename}`,
+        name: file.originalname,
+        size: file.size
+      });
+    }
+  );
   app.get("/api/brand-guidelines/:id/file", async (req, res) => {
     try {
       const file = await readBrandGuidelineFile(
@@ -24904,14 +24982,14 @@ async function startServer({
       }
       const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:T]/g, "-").slice(0, 19);
       const slug = sanitizeSlug(identifier || title || "artifact");
-      const dir = path28.join(ARTIFACTS_DIR, `${stamp}-${slug}`);
-      fs7.mkdirSync(dir, { recursive: true });
-      const file = path28.join(dir, "index.html");
-      fs7.writeFileSync(file, html, "utf8");
+      const dir = path29.join(ARTIFACTS_DIR, `${stamp}-${slug}`);
+      fs8.mkdirSync(dir, { recursive: true });
+      const file = path29.join(dir, "index.html");
+      fs8.writeFileSync(file, html, "utf8");
       const findings = lintArtifact(html);
       res.json({
         path: file,
-        url: `/artifacts/${path28.basename(dir)}/index.html`,
+        url: `/artifacts/${path29.basename(dir)}/index.html`,
         lint: findings
       });
     } catch (err) {
@@ -25954,7 +26032,7 @@ async function startServer({
         const project = getProject(db, req.params.id);
         await ensureProject(PROJECTS_DIR, req.params.id, project?.metadata);
         if (req.file) {
-          const buf2 = await fs7.promises.readFile(req.file.path);
+          const buf2 = await fs8.promises.readFile(req.file.path);
           const desiredName = sanitizeName(
             req.body?.name || req.file.originalname
           );
@@ -25965,7 +26043,7 @@ async function startServer({
             buf2,
             { metadata: project?.metadata }
           );
-          fs7.promises.unlink(req.file.path).catch(() => {
+          fs8.promises.unlink(req.file.path).catch(() => {
           });
           const body2 = { file: meta2 };
           return res.json(body2);
@@ -26112,7 +26190,7 @@ async function startServer({
       res.json({
         projectsDir: PROJECTS_DIR,
         defaultProjectsDir: DEFAULT_PROJECTS_DIR,
-        configured: process.env.OD_FORCE_STORAGE_UNCONFIGURED === "1" ? false : fs7.existsSync(path28.join(RUNTIME_DATA_DIR, "projects-dir.json")),
+        configured: process.env.OD_FORCE_STORAGE_UNCONFIGURED === "1" ? false : fs8.existsSync(path29.join(RUNTIME_DATA_DIR, "projects-dir.json")),
         // Whether the current location is still the DEFAULT. The daemon
         // records the default as the chosen location on first boot (see the
         // auto-write next to PROJECTS_DIR), so `configured` is true out of
@@ -26134,16 +26212,16 @@ async function startServer({
       if (typeof requested !== "string" || !requested.trim()) {
         return res.status(400).json({ error: "projectsDir is required" });
       }
-      const expanded = requested.startsWith("~/") ? path28.join(os4.homedir(), requested.slice(2)) : requested;
-      const resolved = path28.isAbsolute(expanded) ? expanded : path28.resolve(RUNTIME_DATA_DIR, expanded);
+      const expanded = requested.startsWith("~/") ? path29.join(os4.homedir(), requested.slice(2)) : requested;
+      const resolved = path29.isAbsolute(expanded) ? expanded : path29.resolve(RUNTIME_DATA_DIR, expanded);
       try {
-        fs7.mkdirSync(resolved, { recursive: true });
-        fs7.accessSync(resolved, fs7.constants.W_OK);
+        fs8.mkdirSync(resolved, { recursive: true });
+        fs8.accessSync(resolved, fs8.constants.W_OK);
       } catch (e) {
         return res.status(400).json({ error: `Path is not writable: ${e.message}` });
       }
-      const overrideFile = path28.join(RUNTIME_DATA_DIR, "projects-dir.json");
-      fs7.writeFileSync(
+      const overrideFile = path29.join(RUNTIME_DATA_DIR, "projects-dir.json");
+      fs8.writeFileSync(
         overrideFile,
         JSON.stringify({ projectsDir: requested }, null, 2),
         "utf8"
@@ -26153,18 +26231,18 @@ async function startServer({
         try {
           const migrateSources = [
             DEFAULT_PROJECTS_DIR,
-            path28.join(RUNTIME_DATA_DIR, "..", "tf-design-projects-backup")
+            path29.join(RUNTIME_DATA_DIR, "..", "tf-design-projects-backup")
           ];
           let migrated = 0;
           for (const srcDir of migrateSources) {
-            if (!fs7.existsSync(srcDir)) continue;
-            const entries = fs7.readdirSync(srcDir, { withFileTypes: true });
+            if (!fs8.existsSync(srcDir)) continue;
+            const entries = fs8.readdirSync(srcDir, { withFileTypes: true });
             for (const entry of entries) {
               if (!entry.isDirectory()) continue;
-              const src = path28.join(srcDir, entry.name);
-              const dst = path28.join(PROJECTS_DIR, entry.name);
-              if (fs7.existsSync(dst)) continue;
-              fs7.cpSync(src, dst, { recursive: true });
+              const src = path29.join(srcDir, entry.name);
+              const dst = path29.join(PROJECTS_DIR, entry.name);
+              if (fs8.existsSync(dst)) continue;
+              fs8.cpSync(src, dst, { recursive: true });
               migrated++;
             }
           }
@@ -26212,18 +26290,18 @@ async function startServer({
       if (typeof target !== "string" || !target.trim()) {
         return res.status(400).json({ error: "targetDir is required" });
       }
-      const expanded = target.startsWith("~/") ? path28.join(os4.homedir(), target.slice(2)) : target;
-      const resolvedTarget = path28.isAbsolute(expanded) ? expanded : path28.resolve(RUNTIME_DATA_DIR, expanded);
-      fs7.mkdirSync(resolvedTarget, { recursive: true });
+      const expanded = target.startsWith("~/") ? path29.join(os4.homedir(), target.slice(2)) : target;
+      const resolvedTarget = path29.isAbsolute(expanded) ? expanded : path29.resolve(RUNTIME_DATA_DIR, expanded);
+      fs8.mkdirSync(resolvedTarget, { recursive: true });
       const sourceDir = PROJECTS_DIR;
       let migrated = 0;
-      const entries = fs7.readdirSync(sourceDir, { withFileTypes: true });
+      const entries = fs8.readdirSync(sourceDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const src = path28.join(sourceDir, entry.name);
-        const dst = path28.join(resolvedTarget, entry.name);
-        if (fs7.existsSync(dst)) continue;
-        fs7.cpSync(src, dst, { recursive: true });
+        const src = path29.join(sourceDir, entry.name);
+        const dst = path29.join(resolvedTarget, entry.name);
+        if (fs8.existsSync(dst)) continue;
+        fs8.cpSync(src, dst, { recursive: true });
         migrated++;
       }
       res.json({ migrated, targetDir: resolvedTarget });
@@ -26379,7 +26457,7 @@ async function startServer({
         const out = [];
         for (const f of incoming) {
           try {
-            const stat12 = await fs7.promises.stat(f.path);
+            const stat12 = await fs8.promises.stat(f.path);
             out.push({
               name: f.filename,
               path: f.filename,
@@ -26411,10 +26489,17 @@ async function startServer({
     let brandGuidelineBody;
     let brandGuidelineTitle;
     if (effectiveBrandGuidelineId) {
-      const systems = await listBrandGuidelines(BRAND_GUIDELINES_DIR, USER_BRAND_GUIDELINES_DIR);
+      const systems = await listBrandGuidelines(
+        BRAND_GUIDELINES_DIR,
+        USER_BRAND_GUIDELINES_DIR
+      );
       const summary = systems.find((s) => s.id === effectiveBrandGuidelineId);
       brandGuidelineTitle = summary?.title;
-      brandGuidelineBody = await readBrandGuideline(BRAND_GUIDELINES_DIR, USER_BRAND_GUIDELINES_DIR, effectiveBrandGuidelineId) ?? void 0;
+      brandGuidelineBody = await readBrandGuideline(
+        BRAND_GUIDELINES_DIR,
+        USER_BRAND_GUIDELINES_DIR,
+        effectiveBrandGuidelineId
+      ) ?? void 0;
     }
     const template = metadata?.kind === "template" && typeof metadata.templateId === "string" ? getTemplate(db, metadata.templateId) ?? void 0 : void 0;
     const prompt = composeSystemPrompt({
@@ -26487,13 +26572,13 @@ async function startServer({
     }
     if (run.cancelRequested || design.runs.isTerminal(run.status)) return;
     const safeImages = imagePaths.filter((p) => {
-      const resolved = path28.resolve(p);
-      return resolved.startsWith(UPLOAD_DIR + path28.sep) && fs7.existsSync(resolved);
+      const resolved = path29.resolve(p);
+      return resolved.startsWith(UPLOAD_DIR + path29.sep) && fs8.existsSync(resolved);
     });
     const safeAttachments = cwd ? (Array.isArray(attachments) ? attachments : []).filter((p) => typeof p === "string" && p.length > 0).filter((p) => {
       try {
-        const abs = path28.resolve(cwd, p);
-        return (abs === cwd || abs.startsWith(cwd + path28.sep)) && fs7.existsSync(abs);
+        const abs = path29.resolve(cwd, p);
+        return (abs === cwd || abs.startsWith(cwd + path29.sep)) && fs8.existsSync(abs);
       } catch {
         return false;
       }
@@ -26592,9 +26677,9 @@ Attached project files: ${safeAttachments.map((p) => `\`${p}\``).join(", ")}` :
       if (cwd && typeof cwd === "string") {
         for (const name of names) {
           try {
-            const abs = path28.resolve(cwd, name);
-            if (abs !== cwd && abs.startsWith(cwd + path28.sep)) {
-              const content = fs7.readFileSync(abs, "utf8");
+            const abs = path29.resolve(cwd, name);
+            if (abs !== cwd && abs.startsWith(cwd + path29.sep)) {
+              const content = fs8.readFileSync(abs, "utf8");
               if (content.length <= MAX_PER_FILE && used + content.length <= MAX_TOTAL) {
                 used += content.length;
                 snapshot += `
@@ -26795,8 +26880,8 @@ ${safeImages.map((p) => `@${p}`).join(" ")}` : ""
         if (names.length === 0 || !cwd || typeof cwd !== "string") return {};
         const abs = names.map((n) => {
           try {
-            const resolved = path28.resolve(cwd, n);
-            if (resolved === cwd || !resolved.startsWith(cwd + path28.sep))
+            const resolved = path29.resolve(cwd, n);
+            if (resolved === cwd || !resolved.startsWith(cwd + path29.sep))
               return null;
             return resolved;
           } catch {
@@ -26804,7 +26889,7 @@ ${safeImages.map((p) => `@${p}`).join(" ")}` : ""
           }
         }).filter((p) => typeof p === "string");
         if (abs.length === 0) return {};
-        return { OD_MANUAL_EDIT_FILES: abs.join(path28.delimiter) };
+        return { OD_MANUAL_EDIT_FILES: abs.join(path29.delimiter) };
       })();
       const env = {
         ...spawnEnvForAgent(
@@ -26876,7 +26961,7 @@ ${safeImages.map((p) => `@${p}`).join(" ")}` : ""
       } else {
         const critiqueRunId = run.id;
         const critiqueProjectKey = typeof projectId === "string" && projectId ? projectId : critiqueRunId;
-        const critiqueArtifactDir = path28.join(
+        const critiqueArtifactDir = path29.join(
           ARTIFACTS_DIR,
           critiqueProjectKey,
           critiqueRunId
@@ -27126,10 +27211,10 @@ ${safeImages.map((p) => `@${p}`).join(" ")}` : ""
       }
     });
   };
-  const appendVersionedApiPath = (baseUrl, path29) => {
+  const appendVersionedApiPath = (baseUrl, path30) => {
     const url = new URL(baseUrl);
     const trimmed = url.pathname.replace(/\/+$/, "");
-    url.pathname = /\/v\d+(\/|$)/.test(trimmed) ? `${trimmed}${path29}` : `${trimmed}/v1${path29}`;
+    url.pathname = /\/v\d+(\/|$)/.test(trimmed) ? `${trimmed}${path30}` : `${trimmed}/v1${path30}`;
     return url.toString();
   };
   const collectSseFrame = (frame) => {
@@ -27653,6 +27738,8 @@ function isLocalSameOrigin(req, port) {
 }
 
 export {
+  detectLayout,
+  resolveDataRoot,
   resolveProjectRoot,
   resolveDaemonCliPath,
   composeLiveInstructionPrompt,
@@ -27664,6 +27751,7 @@ export {
   renderCommentAttachmentHint,
   resolveDaemonResourceRoot,
   resolveDataDir,
+  dataRoot,
   resolveProjectsDir,
   SSE_KEEPALIVE_INTERVAL_MS,
   createAgentRuntimeEnv,