@superblocksteam/vite-plugin-file-sync 2.0.83-next.1 → 2.0.83

package/dist/ai-service/test-utils/app-generation-mocks/orders-app.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orders-app.js","sourceRoot":"","sources":["../../../../src/ai-service/test-utils/app-generation-mocks/orders-app.ts"],"names":[],"mappings":"AAAA,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kIAo3BmH,CAAC"}

package/dist/ai-service/test-utils/app-generation-mocks/reprompt.d.ts

@@ -0,0 +1,3 @@
+declare const _default: "BUILDING APPLICATION FROM MOCK RESPONSE: I will add a title to the app.\n\n<boltArtifact id=\"hello-world-api-app\" title=\"Hello World API App With Title\">\n<boltAction type=\"file\" filePath=\"pages/Page1/scope.ts\">\nimport { createScope, SbApi } from \"@superblocksteam/library\";\n\nexport const Page1Scope = createScope<{\n  HelloText: any;\n  HelloTitle: any;\n}>(\n  () => ({\n    getHelloWorldApi: SbApi({}),\n  }),\n  {\n    name: \"Page1\",\n  }\n);\n\nexport const Page1 = Page1Scope.entities;\n</boltAction>\n<boltAction type=\"file\" filePath=\"pages/Page1/index.tsx\">\nimport {\n  Page,\n  Dim,\n  Section,\n  Column,\n  Text,\n  Button,\n  EventFlow,\n  computed,\n  registerPage,\n} from \"@superblocksteam/library\";\nimport { Page1, Page1Scope } from \"./scope\";\n\nfunction PageContent() {\n  const { HelloText, HelloTitle, getHelloWorldApi } = Page1;\n\n  return (\n    <Page \n      name=\"Page1\" \n      height={Dim.fill()} \n      width={Dim.fill()}\n      onLoad={EventFlow.runApis([getHelloWorldApi])}\n    >\n      <Section height={Dim.fill()}>\n        <Column width={Dim.fill()} layout=\"vertical\" spacing={Dim.px(12)}>\n          <Text bind={HelloTitle} text=\"This is my hello world app\" />\n          <Button\n            label=\"Fetch Hello World\"\n            onClick={EventFlow.runApis([getHelloWorldApi])}\n          />\n          <Text\n            width={Dim.fit()}\n            height={Dim.fit()}\n            text={computed(() => `${getHelloWorldApi.response || \"\"}`)}\n            bind={HelloText}\n          />\n        </Column>\n      </Section>\n    </Page>\n  );\n}\n\nexport default registerPage(PageContent, Page1Scope);\n</boltAction>\n\n</boltArtifact>\n\nThe app has now a `This is my hello world app` title;";
+export default _default;
+//# sourceMappingURL=reprompt.d.ts.map

package/dist/ai-service/test-utils/app-generation-mocks/reprompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reprompt.d.ts","sourceRoot":"","sources":["../../../../src/ai-service/test-utils/app-generation-mocks/reprompt.ts"],"names":[],"mappings":";AAAA,wBAoEyD"}

package/dist/ai-service/test-utils/app-generation-mocks/reprompt.js

@@ -0,0 +1,70 @@
+export default `BUILDING APPLICATION FROM MOCK RESPONSE: I will add a title to the app.
+
+<boltArtifact id="hello-world-api-app" title="Hello World API App With Title">
+<boltAction type="file" filePath="pages/Page1/scope.ts">
+import { createScope, SbApi } from "@superblocksteam/library";
+
+export const Page1Scope = createScope<{
+  HelloText: any;
+  HelloTitle: any;
+}>(
+  () => ({
+    getHelloWorldApi: SbApi({}),
+  }),
+  {
+    name: "Page1",
+  }
+);
+
+export const Page1 = Page1Scope.entities;
+</boltAction>
+<boltAction type="file" filePath="pages/Page1/index.tsx">
+import {
+  Page,
+  Dim,
+  Section,
+  Column,
+  Text,
+  Button,
+  EventFlow,
+  computed,
+  registerPage,
+} from "@superblocksteam/library";
+import { Page1, Page1Scope } from "./scope";
+
+function PageContent() {
+  const { HelloText, HelloTitle, getHelloWorldApi } = Page1;
+
+  return (
+    <Page 
+      name="Page1" 
+      height={Dim.fill()} 
+      width={Dim.fill()}
+      onLoad={EventFlow.runApis([getHelloWorldApi])}
+    >
+      <Section height={Dim.fill()}>
+        <Column width={Dim.fill()} layout="vertical" spacing={Dim.px(12)}>
+          <Text bind={HelloTitle} text="This is my hello world app" />
+          <Button
+            label="Fetch Hello World"
+            onClick={EventFlow.runApis([getHelloWorldApi])}
+          />
+          <Text
+            width={Dim.fit()}
+            height={Dim.fit()}
+            text={computed(() => \`\${getHelloWorldApi.response || ""}\`)}
+            bind={HelloText}
+          />
+        </Column>
+      </Section>
+    </Page>
+  );
+}
+
+export default registerPage(PageContent, Page1Scope);
+</boltAction>
+
+</boltArtifact>
+
+The app has now a \`This is my hello world app\` title;`;
+//# sourceMappingURL=reprompt.js.map

package/dist/ai-service/test-utils/app-generation-mocks/reprompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reprompt.js","sourceRoot":"","sources":["../../../../src/ai-service/test-utils/app-generation-mocks/reprompt.ts"],"names":[],"mappings":"AAAA,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wDAoEyC,CAAC"}

package/dist/ai-service/test-utils/app-generation-mocks/smoketest.d.ts

@@ -0,0 +1,3 @@
+declare const _default: "BUILDING APPLICATION FROM MOCK RESPONSE: I'll create an app with an API that returns \"Hello World from API App Generation\" and connect it to a text component.\n\n<boltArtifact id=\"hello-world-api-app\" title=\"Hello World API App\">\n<boltAction type=\"file\" filePath=\"pages/Page1/scope.ts\">\nimport { createScope, SbApi } from \"@superblocksteam/library\";\n\nexport const Page1Scope = createScope<{\n  HelloText: any;\n}>(\n  () => ({\n    getHelloWorldApi: SbApi({}),\n  }),\n  {\n    name: \"Page1\",\n  }\n);\n\nexport const Page1 = Page1Scope.entities;\n</boltAction>\n\n<boltAction type=\"file\" filePath=\"pages/Page1/index.tsx\">\nimport {\n  Page,\n  Dim,\n  Section,\n  Column,\n  Text,\n  Button,\n  EventFlow,\n  computed,\n  registerPage,\n} from \"@superblocksteam/library\";\nimport { Page1, Page1Scope } from \"./scope\";\n\nfunction PageContent() {\n  const { HelloText, getHelloWorldApi } = Page1;\n\n  return (\n    <Page\n      name=\"Page1\"\n      height={Dim.fill()}\n      width={Dim.fill()}\n      onLoad={EventFlow.runApis([getHelloWorldApi])}\n    >\n      <Section height={Dim.fill()}>\n        <Column width={Dim.fill()} layout=\"vertical\" spacing={Dim.px(12)}>\n          <Button\n            label=\"Fetch Hello World\"\n            onClick={EventFlow.runApis([getHelloWorldApi])}\n          />\n          <Text\n            width={Dim.fit()}\n            height={Dim.fit()}\n            text={computed(() => `${getHelloWorldApi.response || \"\"}`)}\n            bind={HelloText}\n          />\n        </Column>\n      </Section>\n    </Page>\n  );\n}\n\nexport default registerPage(PageContent, Page1Scope);\n</boltAction>\n\n<boltAction type=\"file\" filePath=\"pages/Page1/apis/getHelloWorldApi.ts\">\nimport {\n  Api,\n  Athena,\n  BigQuery,\n  DynamoDb,\n  JavaScript,\n  Python,\n  Databricks,\n  MicrosoftSql,\n  MySql,\n  Snowflake,\n  PostgreSQL,\n  RestApi,\n  Email,\n  Salesforce,\n  Conditional,\n  TryCatch,\n  Variables,\n  Loop,\n  Parallel,\n  Throw,\n  Return,\n} from \"@superblocksteam/library\";\n\nexport default new Api(\"getHelloWorldApi\", [\n  new JavaScript(\"returnHelloWorld\", {\n    fn: () => {\n      return \"Hello World from API App Generation\";\n    },\n  }),\n]);\n</boltAction>\n</boltArtifact>\n\nThe app is now set up with:\n\n1. **API**: `getHelloWorldApi` that returns the string \"Hello World from API App Generation\"\n2. **Text**: Connected to display the API response value\n3. **Button**: To manually trigger the API call\n4. **Auto-load**: The API runs automatically when the page loads\n\nThe text will show the API response, and you can click the button to refresh the data from the API.";
+export default _default;
+//# sourceMappingURL=smoketest.d.ts.map

package/dist/ai-service/test-utils/app-generation-mocks/smoketest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smoketest.d.ts","sourceRoot":"","sources":["../../../../src/ai-service/test-utils/app-generation-mocks/smoketest.ts"],"names":[],"mappings":";AAAA,wBA2GqG"}

package/dist/ai-service/test-utils/app-generation-mocks/smoketest.js

@@ -0,0 +1,109 @@
+export default `BUILDING APPLICATION FROM MOCK RESPONSE: I'll create an app with an API that returns "Hello World from API App Generation" and connect it to a text component.
+
+<boltArtifact id="hello-world-api-app" title="Hello World API App">
+<boltAction type="file" filePath="pages/Page1/scope.ts">
+import { createScope, SbApi } from "@superblocksteam/library";
+
+export const Page1Scope = createScope<{
+  HelloText: any;
+}>(
+  () => ({
+    getHelloWorldApi: SbApi({}),
+  }),
+  {
+    name: "Page1",
+  }
+);
+
+export const Page1 = Page1Scope.entities;
+</boltAction>
+
+<boltAction type="file" filePath="pages/Page1/index.tsx">
+import {
+  Page,
+  Dim,
+  Section,
+  Column,
+  Text,
+  Button,
+  EventFlow,
+  computed,
+  registerPage,
+} from "@superblocksteam/library";
+import { Page1, Page1Scope } from "./scope";
+
+function PageContent() {
+  const { HelloText, getHelloWorldApi } = Page1;
+
+  return (
+    <Page
+      name="Page1"
+      height={Dim.fill()}
+      width={Dim.fill()}
+      onLoad={EventFlow.runApis([getHelloWorldApi])}
+    >
+      <Section height={Dim.fill()}>
+        <Column width={Dim.fill()} layout="vertical" spacing={Dim.px(12)}>
+          <Button
+            label="Fetch Hello World"
+            onClick={EventFlow.runApis([getHelloWorldApi])}
+          />
+          <Text
+            width={Dim.fit()}
+            height={Dim.fit()}
+            text={computed(() => \`\${getHelloWorldApi.response || ""}\`)}
+            bind={HelloText}
+          />
+        </Column>
+      </Section>
+    </Page>
+  );
+}
+
+export default registerPage(PageContent, Page1Scope);
+</boltAction>
+
+<boltAction type="file" filePath="pages/Page1/apis/getHelloWorldApi.ts">
+import {
+  Api,
+  Athena,
+  BigQuery,
+  DynamoDb,
+  JavaScript,
+  Python,
+  Databricks,
+  MicrosoftSql,
+  MySql,
+  Snowflake,
+  PostgreSQL,
+  RestApi,
+  Email,
+  Salesforce,
+  Conditional,
+  TryCatch,
+  Variables,
+  Loop,
+  Parallel,
+  Throw,
+  Return,
+} from "@superblocksteam/library";
+
+export default new Api("getHelloWorldApi", [
+  new JavaScript("returnHelloWorld", {
+    fn: () => {
+      return "Hello World from API App Generation";
+    },
+  }),
+]);
+</boltAction>
+</boltArtifact>
+
+The app is now set up with:
+
+1. **API**: \`getHelloWorldApi\` that returns the string "Hello World from API App Generation"
+2. **Text**: Connected to display the API response value
+3. **Button**: To manually trigger the API call
+4. **Auto-load**: The API runs automatically when the page loads
+
+The text will show the API response, and you can click the button to refresh the data from the API.`;
+//# sourceMappingURL=smoketest.js.map

package/dist/ai-service/test-utils/app-generation-mocks/smoketest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"smoketest.js","sourceRoot":"","sources":["../../../../src/ai-service/test-utils/app-generation-mocks/smoketest.ts"],"names":[],"mappings":"AAAA,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oGA2GqF,CAAC"}

package/dist/ai-service/test-utils/mock-utils.d.ts

@@ -0,0 +1,12 @@
+export declare const APP_GEN_MOCKS: Record<string, string>;
+export declare const getPromptFromRequest: (requestInit?: RequestInit) => any;
+export declare const getMockContent: (prompt: string) => string;
+export declare function extractMockNameFromPrompt(prompt: string): string | null;
+/**
+ * Splits a mock response into chunks where:
+ * - Simple text sections are kept as single chunks
+ * - Each boltAction (between <boltAction> tags) is kept as a separate, complete chunk
+ * - Preserves the exact content and structure of boltActions
+ */
+export declare function splitGenMockIntoChunks(generationMock: string): string[];
+//# sourceMappingURL=mock-utils.d.ts.map

package/dist/ai-service/test-utils/mock-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-utils.d.ts","sourceRoot":"","sources":["../../../src/ai-service/test-utils/mock-utils.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAIhD,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,cAAc,WAAW,QAc7D,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,QAAQ,MAAM,KAAG,MAS/C,CAAC;AAEF,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGvE;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,EAAE,CAqCvE"}

package/dist/ai-service/test-utils/mock-utils.js

@@ -0,0 +1,70 @@
+import ordersAppMockContent from "./app-generation-mocks/orders-app.js";
+import repromptMockContent from "./app-generation-mocks/reprompt.js";
+import smoketestMockContent from "./app-generation-mocks/smoketest.js";
+export const APP_GEN_MOCKS = {
+    smoketest: smoketestMockContent,
+    orders_app: ordersAppMockContent,
+    reprompt: repromptMockContent,
+};
+export const getPromptFromRequest = (requestInit) => {
+    if (!requestInit) {
+        return "";
+    }
+    const body = JSON.parse(requestInit.body);
+    const userMessage = body.messages.filter((message) => message.role === "user")[0].content[0].text;
+    // filter out old prompts to only get the new one if its a reprompt
+    if (userMessage.includes("new prompt is:")) {
+        return userMessage.split("new prompt is:")[1].trim();
+    }
+    return userMessage;
+};
+export const getMockContent = (prompt) => {
+    const mockName = extractMockNameFromPrompt(prompt);
+    if (mockName && APP_GEN_MOCKS[mockName]) {
+        return APP_GEN_MOCKS[mockName];
+    }
+    return ("Could not find mock content for prompt. Please use a valid mock name with structure SB_MOCK_APP_<mock-name>. Currently available mocks are: " +
+        Object.keys(APP_GEN_MOCKS).join(", "));
+};
+export function extractMockNameFromPrompt(prompt) {
+    const mockMatch = prompt.match(/^SB_MOCK_APP_(\w+)$/);
+    return mockMatch?.[1] || null;
+}
+/**
+ * Splits a mock response into chunks where:
+ * - Simple text sections are kept as single chunks
+ * - Each boltAction (between <boltAction> tags) is kept as a separate, complete chunk
+ * - Preserves the exact content and structure of boltActions
+ */
+export function splitGenMockIntoChunks(generationMock) {
+    const chunks = [];
+    let currentIndex = 0;
+    // Regular expression to match boltAction tags with their content
+    const boltActionRegex = /<boltAction[^>]*>[\s\S]*?<\/boltAction>/g;
+    let match;
+    while ((match = boltActionRegex.exec(generationMock)) !== null) {
+        const boltActionStart = match.index;
+        const boltActionEnd = boltActionStart + match[0].length;
+        // Add any text before this boltAction as a text chunk
+        if (boltActionStart > currentIndex) {
+            const textContent = generationMock
+                .slice(currentIndex, boltActionStart)
+                .trim();
+            if (textContent) {
+                chunks.push(textContent);
+            }
+        }
+        // Add the boltAction as a separate chunk
+        chunks.push(match[0]);
+        currentIndex = boltActionEnd;
+    }
+    // Add any remaining text after the last boltAction
+    if (currentIndex < generationMock.length) {
+        const textContent = generationMock.slice(currentIndex).trim();
+        if (textContent) {
+            chunks.push(textContent);
+        }
+    }
+    return chunks;
+}
+//# sourceMappingURL=mock-utils.js.map

package/dist/ai-service/test-utils/mock-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-utils.js","sourceRoot":"","sources":["../../../src/ai-service/test-utils/mock-utils.ts"],"names":[],"mappings":"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"}

package/dist/ai-service/util/safe-stringify.d.ts

@@ -0,0 +1,2 @@
+export declare function safeJsonStringify(obj: unknown, space?: string | number): string;
+//# sourceMappingURL=safe-stringify.d.ts.map

package/dist/ai-service/util/safe-stringify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-stringify.d.ts","sourceRoot":"","sources":["../../../src/ai-service/util/safe-stringify.ts"],"names":[],"mappings":"AAQA,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,OAAO,EACZ,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GACtB,MAAM,CA0ER"}

package/dist/ai-service/util/safe-stringify.js

@@ -0,0 +1,75 @@
+const SENSITIVE_KEYS = [
+    "password",
+    "api_key",
+    "jwt",
+    "access_token",
+    "refresh_token",
+];
+export function safeJsonStringify(obj, space) {
+    if (obj === null || obj === undefined) {
+        return "{}";
+    }
+    if (typeof obj === "string") {
+        return obj;
+    }
+    const seen = new WeakSet();
+    return JSON.stringify(obj, (key, value) => {
+        // Handle null and primitives first
+        if (value === null || value === undefined) {
+            return value;
+        }
+        if (SENSITIVE_KEYS.includes(key.toLowerCase())) {
+            return "[REDACTED]";
+        }
+        // Handle circular references
+        if (typeof value === "object") {
+            if (seen.has(value)) {
+                return "[Circular Reference]";
+            }
+            seen.add(value);
+            if (value instanceof Error) {
+                return {
+                    message: value.message,
+                    stack: value.stack,
+                    name: value.name,
+                };
+            }
+            // Check for toJSON method that might be broken
+            if (typeof value.toJSON === "function") {
+                try {
+                    const jsonValue = value.toJSON();
+                    // Recursively check if the result is serializable
+                    return jsonValue;
+                }
+                catch (_error) {
+                    // If toJSON throws, treat as non-serializable
+                    return `[Object with broken toJSON: ${value.constructor?.name || "unknown"}]`;
+                }
+            }
+        }
+        // Try to serialize the value
+        try {
+            // This will throw if the value is not serializable
+            JSON.stringify(value, null, space);
+            return value;
+        }
+        catch (_error) {
+            // Handle non-serializable types
+            if (typeof value === "function") {
+                return `[Function: ${value.name || "anonymous"}]`;
+            }
+            if (typeof value === "symbol") {
+                return `[Symbol: ${value.toString()}]`;
+            }
+            if (typeof value === "bigint") {
+                return `[BigInt: ${value.toString()}]`;
+            }
+            if (typeof value === "object") {
+                // For objects that can't be serialized
+                return "[Non-serializable]";
+            }
+            return "[Non-serializable]";
+        }
+    }, space);
+}
+//# sourceMappingURL=safe-stringify.js.map

package/dist/ai-service/util/safe-stringify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-stringify.js","sourceRoot":"","sources":["../../../src/ai-service/util/safe-stringify.ts"],"names":[],"mappings":"AAAA,MAAM,cAAc,GAAG;IACrB,UAAU;IACV,SAAS;IACT,KAAK;IACL,cAAc;IACd,eAAe;CAChB,CAAC;AAEF,MAAM,UAAU,iBAAiB,CAC/B,GAAY,EACZ,KAAuB;IAEvB,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QACtC,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;QAC5B,OAAO,GAAG,CAAC;IACb,CAAC;IACD,MAAM,IAAI,GAAG,IAAI,OAAO,EAAE,CAAC;IAE3B,OAAO,IAAI,CAAC,SAAS,CACnB,GAAG,EACH,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE;QACb,mCAAmC;QACnC,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YAC1C,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,cAAc,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC;YAC/C,OAAO,YAAY,CAAC;QACtB,CAAC;QAED,6BAA6B;QAC7B,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9B,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;gBACpB,OAAO,sBAAsB,CAAC;YAChC,CAAC;YACD,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YAEhB,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;gBAC3B,OAAO;oBACL,OAAO,EAAE,KAAK,CAAC,OAAO;oBACtB,KAAK,EAAE,KAAK,CAAC,KAAK;oBAClB,IAAI,EAAE,KAAK,CAAC,IAAI;iBACjB,CAAC;YACJ,CAAC;YAED,+CAA+C;YAC/C,IAAI,OAAO,KAAK,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;gBACvC,IAAI,CAAC;oBACH,MAAM,SAAS,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;oBACjC,kDAAkD;oBAClD,OAAO,SAAS,CAAC;gBACnB,CAAC;gBAAC,OAAO,MAAM,EAAE,CAAC;oBAChB,8CAA8C;oBAC9C,OAAO,+BAA+B,KAAK,CAAC,WAAW,EAAE,IAAI,IAAI,SAAS,GAAG,CAAC;gBAChF,CAAC;YACH,CAAC;QACH,CAAC;QAED,6BAA6B;QAC7B,IAAI,CAAC;YACH,mDAAmD;YACnD,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;YACnC,OAAO,KAAK,CAAC;QACf,CAAC;QAAC,OAAO,MAAM,EAAE,CAAC;YAChB,gCAAgC;YAChC,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE,CAAC;gBAChC,OAAO,cAAc,KAAK,CAAC,IAAI,IAAI,WAAW,GAAG,CAAC;YACpD,CAAC;YACD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;gBAC9B,OAAO,YAAY,KAAK,CAAC,QAAQ,EAAE,GAAG,CAAC;YACzC,CAAC;YACD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;gBAC9B,OAAO,YAAY,KAAK,CAAC,QAAQ,EAAE,GAAG,CAAC;YACzC,CAAC;YACD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;gBAC9B,uCAAuC;gBACvC,OAAO,oBAAoB,CAAC;YAC9B,CAAC;YACD,OAAO,oBAAoB,CAAC;QAC9B,CAAC;IACH,CAAC,EACD,KAAK,CACN,CAAC;AACJ,CAAC"}

package/dist/file-sync-vite-plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-sync-vite-plugin.d.ts","sourceRoot":"","sources":["../src/file-sync-vite-plugin.ts"],"names":[],"mappings":"AA+CA,OAAO,KAAK,EACV,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAW7B,OAAO,KAAK,EAAE,MAAM,EAA0B,MAAM,MAAM,CAAC;AAY3D,eAAO,MAAM,kBAAkB,EAAE,CAC/B,YAAY,EAAE,oBAAoB,EAClC,OAAO,CAAC,EAAE,qBAAqB,KAC5B;IAAE,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,IAAI,CAAA;CAk0C3C,CAAC"}
+{"version":3,"file":"file-sync-vite-plugin.d.ts","sourceRoot":"","sources":["../src/file-sync-vite-plugin.ts"],"names":[],"mappings":"AA+CA,OAAO,KAAK,EACV,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAW7B,OAAO,KAAK,EAAE,MAAM,EAA0B,MAAM,MAAM,CAAC;AAY3D,eAAO,MAAM,kBAAkB,EAAE,CAC/B,YAAY,EAAE,oBAAoB,EAClC,OAAO,CAAC,EAAE,qBAAqB,KAC5B;IAAE,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,IAAI,CAAA;CAgyC3C,CAAC"}

package/dist/file-sync-vite-plugin.js

@@ -64,12 +64,6 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
             await aiService.waitUntilGenerationComplete();
         });
     }
-    // Wire up commit ID updates for recording sessions
-    if (aiService && syncService) {
-        syncService.on("commitIdChanged", (commitId) => {
-            void aiService.getRecordingManager().setCurrentCommitId(commitId);
-        });
-    }
     const componentsManager = ComponentsManager.setInstance(pluginParams.tracer);
     const lastImportErrorFiles = new Set();
     let isFirstContentfulGeneration = true;
@@ -97,7 +91,6 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
         apply: "serve",
         enforce: "pre",
         async configureServer(server) {
-            const tracer = pluginParams.tracer;
             config = server.config;
             // Set up Vite module invalidation callback for SyncService
             // This ensures that when Clark writes files, Vite's module cache is invalidated
@@ -111,9 +104,9 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
                     }
                 });
             }
-            // Wrap logger.error to forward errors to AI and track them,
-            // while downgrading Vite errors to info level for our own logger.
-            // User notification is unaffected — Vite still sends vite:error via HMR.
+            // Wrap logger.error to send errors to AI when it's busy
+            // Otherwise, let errors flow naturally through Vite's error handling
+            const originalErrorLogger = config.logger.error;
             config.logger.error = (message, options) => {
                 if (aiService?.isBusy()) {
                     void aiService.handleBuildSystemError(new Error(message));
@@ -121,18 +114,13 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
                 if (options?.error) {
                     loggedViteErrors.push(options.error);
                 }
-                logger.info("[vite-plugin] Build system error", { message });
+                // Let the error be logged normally regardless
+                // Vite will handle sending it to the client via HMR
+                return originalErrorLogger.apply(config.logger, [message, options]);
             };
             createIdResolver(server.config, server.environments.client);
             await Promise.all([
-                tracer.startActiveSpan("componentsManagerInitialize", async (compSpan) => {
-                    try {
-                        await componentsManager.initialize(process.cwd(), server.watcher);
-                    }
-                    finally {
-                        compSpan.end();
-                    }
-                }),
+                componentsManager.initialize(process.cwd(), server.watcher),
                 server.waitForRequestsIdle("sb-file-sync").then(async () => {
                     if (hasStarted) {
                         // We only want to initialize the file sync once, but vite seems to fire this multiple times
@@ -141,15 +129,8 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
                     hasStarted = true;
                     const root = server.config.root;
                     try {
-                        await tracer.startActiveSpan("fileSyncManagerWatch", async (watchSpan) => {
-                            try {
-                                await fileSyncManager.watch(server.watcher, root).then(() => {
-                                    isInitialized = true;
-                                });
-                            }
-                            finally {
-                                watchSpan.end();
-                            }
+                        await fileSyncManager.watch(server.watcher, root).then(() => {
+                            isInitialized = true;
                         });
                     }
                     catch (e) {
@@ -307,22 +288,15 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
                 })();
             });
             socketManager = createSocketManager(pluginParams.tracer);
-            await tracer.startActiveSpan("socketServerStart", async (socketSpan) => {
-                try {
-                    socketManager.startSocketServer({
-                        server: httpServer,
-                        fileSyncManager,
-                        lockService,
-                        syncService,
-                        aiService,
-                        checkAuthorization: pluginParams.checkAuthorization,
-                        tracer: pluginParams.tracer,
-                        path: "/sb-updates",
-                    });
-                }
-                finally {
-                    socketSpan.end();
-                }
+            socketManager.startSocketServer({
+                server: httpServer,
+                fileSyncManager,
+                lockService,
+                syncService,
+                aiService,
+                checkAuthorization: pluginParams.checkAuthorization,
+                tracer: pluginParams.tracer,
+                path: "/sb-updates",
             });
             socketManager.removeAllListeners();
             const sendError = (errorEvent) => {
@@ -338,8 +312,7 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
                 sendError(makeServerError(error));
             });
             process.on("unhandledRejection", (reason) => {
-                const reasonStr = JSON.stringify(reason);
-                logger.error(`Unhandled rejection: ${reasonStr}`);
+                logger.error(`Unhandled rejection: ${JSON.stringify(reason)}`);
                 const error = reason instanceof Error
                     ? reason
                     : typeof reason === "object"
@@ -608,8 +581,7 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
                                 await socket.call.syncStatus({ status, generationNumber });
                             }
                             catch (err) {
-                                // Failed to send is expected when clients disconnect - log as WARNING
-                                logger.warn("Failed to send syncStatus", getErrorMeta(err));
+                                logger.error("Failed to send syncStatus", getErrorMeta(err));
                             }
                         });
                     })();
@@ -624,8 +596,7 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
                                 await socket.call.releasingLock();
                             }
                             catch (err) {
-                                // Failed to send is expected when clients disconnect - log as WARNING
-                                logger.warn("Failed to send releasingLock", getErrorMeta(err));
+                                logger.error("Failed to send releasingLock", getErrorMeta(err));
                             }
                         });
                     }
@@ -636,8 +607,7 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
                             await socket.call.closedByServer(data);
                         }
                         catch (err) {
-                            // Failed to send is expected when clients disconnect - log as WARNING
-                            logger.warn("Failed to send closedByServer", getErrorMeta(err));
+                            logger.error("Failed to send releasingLock", getErrorMeta(err));
                         }
                     });
                 });