@standardagents/builder 0.40.5-next.3b25e2a → 0.40.5

package/dist/runtime.js

@@ -1,11 +1,13 @@
 import { getProviderModelPricing } from '@standardagents/provider-pricing';
 import { jsonPathReader } from '@formkit/jsonreader';
 import { ProviderError, mapReasoningLevel, THREAD_STREAM_REASONING_PARAM, isUserEndpoint } from '@standardagents/spec';
-export { ProviderError, belongsToPackage, defineAgent, defineHook, defineModel, definePrompt, defineTool, isPacked, isVisibleInNamespace, mapReasoningLevel } from '@standardagents/spec';
+export { ProviderError, belongsToPackage, defineAgent, defineHook, defineModel, definePrompt, defineProvider, defineTool, isPacked, isVisibleInNamespace, mapReasoningLevel, providerConst, providerEnv, providerValue } from '@standardagents/spec';
 import 'virtual:@standardagents-providers';
 import { z } from 'zod';
 import { transform, collect } from '@standardagents/sip';
 import { DurableObject, WorkerEntrypoint } from 'cloudflare:workers';
+import 'fs';
+import 'path';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -454,8 +456,8 @@ async function readCompletedArg(partialJson, argName) {
         controller.close();
       }
     }).getReader();
-    for await (const [value, path] of jsonPathReader(reader, [argName])) {
-      if (path === argName) {
+    for await (const [value, path2] of jsonPathReader(reader, [argName])) {
+      if (path2 === argName) {
         return typeof value === "string" ? value : void 0;
       }
     }
@@ -1535,11 +1537,11 @@ function stripBase64FromMessages(messages, imagePathMap) {
             const data = part.data;
             if (typeof data === "string") {
               if (data.startsWith("data:") || data.length > 1e3) {
-                const path = imagePathMap?.get(data);
+                const path2 = imagePathMap?.get(data);
                 return {
                   ...part,
                   data: "[base64 omitted]",
-                  ...path ? { path } : {}
+                  ...path2 ? { path: path2 } : {}
                 };
               }
             }
@@ -2105,14 +2107,14 @@ var init_LLMRequest = __esm({
        */
       static async callModel(modelId, context, state, logId) {
         const { ProviderRegistry: ProviderRegistry2 } = await Promise.resolve().then(() => (init_providers(), providers_exports));
-        const providerEnv = await ProviderRegistry2.buildThreadScopedEnv(state);
+        const providerEnv2 = await ProviderRegistry2.buildThreadScopedEnv(state);
         const getThreadState = async () => {
           const { ThreadStateImpl: ThreadStateImpl2 } = await Promise.resolve().then(() => (init_ThreadStateImpl(), ThreadStateImpl_exports));
           return ThreadStateImpl2.fromFlowState(state);
         };
         const { provider, modelName, modelDef, viaPlatform, platformProxyOrigin } = await ProviderRegistry2.getProvider(
           modelId,
-          providerEnv,
+          providerEnv2,
           state.thread.instance,
           getThreadState
         );
@@ -2755,11 +2757,11 @@ var init_LLMRequest = __esm({
               ...choice.message,
               images: choice.message?.images?.map(
                 (img) => {
-                  const path = img._id ? imagePathMap.get(img._id) : void 0;
-                  if (path) {
+                  const path2 = img._id ? imagePathMap.get(img._id) : void 0;
+                  if (path2) {
                     return {
                       type: img.type,
-                      image_url: { url: path }
+                      image_url: { url: path2 }
                     };
                   }
                   return img;
@@ -3286,20 +3288,20 @@ function detectStorageBackend(location) {
     return "url";
   return "local";
 }
-function basename(path) {
-  const parts = path.split("/").filter(Boolean);
+function basename(path2) {
+  const parts = path2.split("/").filter(Boolean);
   return parts[parts.length - 1] || "";
 }
-function normalizePath(path) {
-  let normalized = path.replace(/\/+/g, "/");
+function normalizePath(path2) {
+  let normalized = path2.replace(/\/+/g, "/");
   if (!normalized.startsWith("/")) normalized = "/" + normalized;
   if (normalized.length > 1 && normalized.endsWith("/")) {
     normalized = normalized.slice(0, -1);
   }
   return normalized;
 }
-function dirname(path) {
-  const normalized = normalizePath(path);
+function dirname(path2) {
+  const normalized = normalizePath(path2);
   const lastSlash = normalized.lastIndexOf("/");
   if (lastSlash <= 0) return "/";
   return normalized.slice(0, lastSlash);
@@ -3317,7 +3319,7 @@ function validateMovePaths(source, destination, isDirectory) {
     );
   }
 }
-function resolveRenameDestination(path, newName) {
+function resolveRenameDestination(path2, newName) {
   if (typeof newName !== "string" || newName.length === 0) {
     throw new Error("New name must be a non-empty string");
   }
@@ -3327,7 +3329,7 @@ function resolveRenameDestination(path, newName) {
   if (newName === "." || newName === "..") {
     throw new Error("New name must not be '.' or '..'");
   }
-  const normalized = normalizePath(path);
+  const normalized = normalizePath(path2);
   const parent = dirname(normalized);
   return parent === "/" ? `/${newName}` : `${parent}/${newName}`;
 }
@@ -3451,8 +3453,8 @@ var init_files = __esm({
        * Write a file to storage.
        * Files > CHUNK_SIZE are automatically chunked into file_chunks table.
        */
-      async writeFile(path, data, mimeType, options) {
-        const normalizedPath = normalizePath(path);
+      async writeFile(path2, data, mimeType, options) {
+        const normalizedPath = normalizePath(path2);
         const name = basename(normalizedPath);
         const isText = isTextMimeType(mimeType);
         const now = Date.now();
@@ -3564,8 +3566,8 @@ var init_files = __esm({
       /**
        * Link to an external file (URL, S3, R2)
        */
-      async linkFile(path, location, options) {
-        const normalizedPath = normalizePath(path);
+      async linkFile(path2, location, options) {
+        const normalizedPath = normalizePath(path2);
         const name = basename(normalizedPath);
         const storage = detectStorageBackend(location);
         const now = Date.now();
@@ -3604,8 +3606,8 @@ var init_files = __esm({
        * WARNING: For large chunked files, this loads the entire file into memory.
        * Use streamFile() for memory-efficient access to large files.
        */
-      async readFile(path) {
-        const normalizedPath = normalizePath(path);
+      async readFile(path2) {
+        const normalizedPath = normalizePath(path2);
         const cursor = await this.sql.exec(
           `SELECT data, content, storage, is_chunked, chunk_count FROM files WHERE path = ? AND is_directory = 0`,
           normalizedPath
@@ -3657,8 +3659,8 @@ var init_files = __esm({
        * Memory-efficient way to read large chunked files.
        * Yields one chunk at a time for streaming HTTP responses.
        */
-      async *streamFile(path) {
-        const normalizedPath = normalizePath(path);
+      async *streamFile(path2) {
+        const normalizedPath = normalizePath(path2);
         const cursor = await this.sql.exec(
           `SELECT data, content, storage, is_chunked, chunk_count FROM files WHERE path = ? AND is_directory = 0`,
           normalizedPath
@@ -3692,8 +3694,8 @@ var init_files = __esm({
       /**
        * Read text file content
        */
-      async readTextFile(path) {
-        const normalizedPath = normalizePath(path);
+      async readTextFile(path2) {
+        const normalizedPath = normalizePath(path2);
         const cursor = await this.sql.exec(
           `SELECT content, data, storage FROM files WHERE path = ? AND is_directory = 0`,
           normalizedPath
@@ -3711,8 +3713,8 @@ var init_files = __esm({
       /**
        * Get file metadata (stat)
        */
-      async stat(path) {
-        const normalizedPath = normalizePath(path);
+      async stat(path2) {
+        const normalizedPath = normalizePath(path2);
         const cursor = await this.sql.exec(
           `SELECT path, name, mime_type, storage, location, size, metadata, is_directory, created_at, width, height, is_chunked, chunk_count
        FROM files WHERE path = ?`,
@@ -3725,8 +3727,8 @@ var init_files = __esm({
       /**
        * Check if file or directory exists
        */
-      async exists(path) {
-        const normalizedPath = normalizePath(path);
+      async exists(path2) {
+        const normalizedPath = normalizePath(path2);
         const cursor = await this.sql.exec(
           `SELECT COUNT(*) as count FROM files WHERE path = ?`,
           normalizedPath
@@ -3736,8 +3738,8 @@ var init_files = __esm({
       /**
        * Delete a file
        */
-      async unlink(path) {
-        const normalizedPath = normalizePath(path);
+      async unlink(path2) {
+        const normalizedPath = normalizePath(path2);
         await this.sql.exec(
           `DELETE FROM files WHERE path = ? AND is_directory = 0`,
           normalizedPath
@@ -3747,8 +3749,8 @@ var init_files = __esm({
       /**
        * Create a directory marker
        */
-      async mkdir(path) {
-        const normalizedPath = normalizePath(path);
+      async mkdir(path2) {
+        const normalizedPath = normalizePath(path2);
         const name = basename(normalizedPath);
         const now = Date.now();
         await this.sql.exec(
@@ -3773,8 +3775,8 @@ var init_files = __esm({
       /**
        * List directory contents
        */
-      async readdir(path) {
-        const normalizedPath = normalizePath(path);
+      async readdir(path2) {
+        const normalizedPath = normalizePath(path2);
         const prefix = normalizedPath === "/" ? "/" : normalizedPath + "/";
         const cursor = await this.sql.exec(
           `SELECT path, name, mime_type, storage, location, size, metadata, is_directory, created_at
@@ -3792,8 +3794,8 @@ var init_files = __esm({
       /**
        * Remove empty directory
        */
-      async rmdir(path) {
-        const normalizedPath = normalizePath(path);
+      async rmdir(path2) {
+        const normalizedPath = normalizePath(path2);
         const prefix = normalizedPath + "/";
         const cursor = await this.sql.exec(
           `SELECT COUNT(*) as count FROM files WHERE path LIKE ? || '%'`,
@@ -3891,9 +3893,9 @@ var init_files = __esm({
        * Rename a file or directory in place, keeping it in the same parent
        * directory. `newName` must be a bare file name with no path separators.
        */
-      async rename(path, newName) {
-        const destination = resolveRenameDestination(path, newName);
-        return this.move(normalizePath(path), destination);
+      async rename(path2, newName) {
+        const destination = resolveRenameDestination(path2, newName);
+        return this.move(normalizePath(path2), destination);
       }
       /**
        * Get storage statistics
@@ -3923,8 +3925,8 @@ var init_files = __esm({
       /**
        * Get thumbnail for an image
        */
-      async getThumbnail(path) {
-        const normalizedPath = normalizePath(path);
+      async getThumbnail(path2) {
+        const normalizedPath = normalizePath(path2);
         const cursor = await this.sql.exec(
           `SELECT thumbnail FROM files WHERE path = ? AND is_directory = 0`,
           normalizedPath
@@ -4375,8 +4377,8 @@ var init_ToolExecutor = __esm({
             const validation = argsSchema.safeParse(args);
             if (!validation.success) {
               const errorMessage = validation.error.issues.map((issue) => {
-                const path = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
-                return `[${path}] ${issue.message}`;
+                const path2 = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
+                return `[${path2}] ${issue.message}`;
               }).join("; ");
               return {
                 status: "error",
@@ -5074,9 +5076,7 @@ Message one with subagent_message(referenceId, message).`
             if (resumable) {
               await this.settleResumableChildAfterRun(
                 state,
-                stub,
-                childThreadId,
-                childResult
+                childThreadId
               );
             } else if (stub.terminateThread) {
               await stub.terminateThread(childThreadId);
@@ -5088,7 +5088,7 @@ Message one with subagent_message(referenceId, message).`
               attachments: copiedAttachments,
               subagent_id: childThreadId
             };
-            return resumable && !this.isTerminalSubagentResult(childResult) ? this.withReferenceInToolResult(toolResult, childThreadId) : toolResult;
+            return resumable ? this.withReferenceInToolResult(toolResult, childThreadId) : toolResult;
           }
           const backgroundRun = (async () => {
             try {
@@ -5123,9 +5123,7 @@ Message one with subagent_message(referenceId, message).`
               if (resumable) {
                 await this.settleResumableChildAfterRun(
                   state,
-                  stub,
-                  childThreadId,
-                  childResult
+                  childThreadId
                 );
               } else if (stub.terminateThread) {
                 await stub.terminateThread(childThreadId);
@@ -5374,13 +5372,13 @@ Message one with subagent_message(referenceId, message).`
             new Set(
               issues.map(
                 (issue) => Array.isArray(issue.path) ? issue.path.map(String).join(".") : String(issue.path ?? "")
-              ).filter((path) => path.length > 0)
+              ).filter((path2) => path2.length > 0)
             )
           );
           const detail = issues.map((issue) => {
-            const path = Array.isArray(issue.path) ? issue.path.map(String).join(".") : "";
+            const path2 = Array.isArray(issue.path) ? issue.path.map(String).join(".") : "";
             const message = typeof issue.message === "string" ? issue.message : "invalid value";
-            return path ? `${path}: ${message}` : message;
+            return path2 ? `${path2}: ${message}` : message;
           }).join("; ") || parsed.error.message || "invalid arguments";
           const agentLabel = agentDef.title || agentDef.name || options.agentName || qualifiedPromptName;
           return {
@@ -5520,18 +5518,8 @@ Message one with subagent_message(referenceId, message).`
           JSON.stringify(next)
         );
       }
-      static isTerminalSubagentResult(result) {
-        return result.terminal === true;
-      }
-      static async settleResumableChildAfterRun(state, childThread, reference, result) {
-        if (!this.isTerminalSubagentResult(result)) {
-          await this.updateChildStatus(state, reference, "idle");
-          return;
-        }
-        await this.updateChildStatus(state, reference, "terminated");
-        if (typeof childThread.terminateThread === "function") {
-          await childThread.terminateThread(reference);
-        }
+      static async settleResumableChildAfterRun(state, reference) {
+        await this.updateChildStatus(state, reference, "idle");
       }
       static async buildChildInvocationMessages(state, childThread, content, receivesMessages, parentAttachments, initialArguments) {
         const copiedAttachments = await this.copyAttachmentsBetweenThreads(
@@ -5739,8 +5727,8 @@ Reference: ${referenceId}` : `Reference: ${referenceId}`;
         }
         return [];
       }
-      static inferMimeTypeFromPath(path) {
-        const normalized = path.toLowerCase();
+      static inferMimeTypeFromPath(path2) {
+        const normalized = path2.toLowerCase();
         if (normalized.endsWith(".png")) return "image/png";
         if (normalized.endsWith(".jpg") || normalized.endsWith(".jpeg")) return "image/jpeg";
         if (normalized.endsWith(".webp")) return "image/webp";
@@ -5779,7 +5767,7 @@ Reference: ${referenceId}` : `Reference: ${referenceId}`;
           ext: value.slice(lastDot + 1).toLowerCase()
         };
       }
-      static resolveAttachmentMimeType(sourceMimeType, fallbackMimeType, path) {
+      static resolveAttachmentMimeType(sourceMimeType, fallbackMimeType, path2) {
         const source = sourceMimeType?.trim();
         if (source && source !== "application/octet-stream") {
           return source;
@@ -5788,7 +5776,7 @@ Reference: ${referenceId}` : `Reference: ${referenceId}`;
         if (fallback && fallback !== "application/octet-stream") {
           return fallback;
         }
-        return this.inferMimeTypeFromPath(path) ?? source ?? fallback ?? "application/octet-stream";
+        return this.inferMimeTypeFromPath(path2) ?? source ?? fallback ?? "application/octet-stream";
       }
       static buildAttachmentTargetPath(preferredName, mimeType, sourcePath) {
         const safeName = this.sanitizeFilename(preferredName);
@@ -5885,8 +5873,8 @@ Reference: ${referenceId}` : `Reference: ${referenceId}`;
         }
         return copied;
       }
-      static async readAttachmentDataFromSource(sourceThread, path, sourceFile, allowedAttachmentFetchHosts) {
-        const sourceData = await sourceThread.readFile(path);
+      static async readAttachmentDataFromSource(sourceThread, path2, sourceFile, allowedAttachmentFetchHosts) {
+        const sourceData = await sourceThread.readFile(path2);
         if (sourceData.success && sourceData.data) {
           return sourceData.data;
         }
@@ -5923,7 +5911,7 @@ Reference: ${referenceId}` : `Reference: ${referenceId}`;
         if (!attachments || attachments.length === 0) {
           return "";
         }
-        const paths = attachments.map((attachment) => attachment.path).filter((path) => typeof path === "string" && path.length > 0);
+        const paths = attachments.map((attachment) => attachment.path).filter((path2) => typeof path2 === "string" && path2.length > 0);
         if (paths.length === 0) {
           return "";
         }
@@ -6220,7 +6208,7 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
                   mappedAttachmentValue
                 );
                 const resolvedPaths = new Set(mappedRefs.map((ref) => ref.path));
-                const missingPaths = candidatePaths.filter((path) => !resolvedPaths.has(path));
+                const missingPaths = candidatePaths.filter((path2) => !resolvedPaths.has(path2));
                 if (candidatePaths.length === 0 || missingPaths.length > 0) {
                   processedResult = {
                     status: "error",
@@ -6402,8 +6390,8 @@ ${attachmentPaths}`;
           if (mimeType.startsWith("image/")) {
             return true;
           }
-          const path = ref.path.toLowerCase();
-          return path.endsWith(".png") || path.endsWith(".jpg") || path.endsWith(".jpeg") || path.endsWith(".webp") || path.endsWith(".gif") || path.endsWith(".bmp") || path.endsWith(".svg");
+          const path2 = ref.path.toLowerCase();
+          return path2.endsWith(".png") || path2.endsWith(".jpg") || path2.endsWith(".jpeg") || path2.endsWith(".webp") || path2.endsWith(".gif") || path2.endsWith(".bmp") || path2.endsWith(".svg");
         });
         if (imageRefs.length === 0) {
           return;
@@ -6469,27 +6457,27 @@ ${attachmentPaths}`;
        */
       static async processToolAttachments(attachments, state) {
         const { FileStorage: FileStorage2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-        const fs = new FileStorage2(state.storage.sql);
+        const fs2 = new FileStorage2(state.storage.sql);
         const refs = [];
         for (const attachment of attachments) {
           try {
             const attachmentId = crypto.randomUUID();
             const timestamp = Date.now();
             const ext = attachment.mimeType === "image/png" ? "png" : attachment.mimeType === "image/jpeg" ? "jpg" : attachment.mimeType === "image/gif" ? "gif" : attachment.mimeType === "image/webp" ? "webp" : attachment.name.split(".").pop() || "bin";
-            const path = `/attachments/${timestamp}-${attachmentId.slice(0, 8)}.${ext}`;
+            const path2 = `/attachments/${timestamp}-${attachmentId.slice(0, 8)}.${ext}`;
             const binaryString = atob(attachment.data);
             const dataBuffer = new Uint8Array(binaryString.length);
             for (let i = 0; i < binaryString.length; i++) {
               dataBuffer[i] = binaryString.charCodeAt(i);
             }
-            await fs.writeFile(path, dataBuffer.buffer, attachment.mimeType, {
+            await fs2.writeFile(path2, dataBuffer.buffer, attachment.mimeType, {
               width: attachment.width,
               height: attachment.height
             });
             const ref = {
               id: attachmentId,
               type: "file",
-              path,
+              path: path2,
               name: attachment.name,
               mimeType: attachment.mimeType,
               size: dataBuffer.byteLength
@@ -10852,20 +10840,20 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
             continue;
           }
           const attachmentId = crypto.randomUUID();
-          const path = `/attachments/${Date.now()}-${attachmentId.slice(0, 8)}.${ext}`;
+          const path2 = `/attachments/${Date.now()}-${attachmentId.slice(0, 8)}.${ext}`;
           try {
-            const written = await state.thread.instance.writeFile(path, base64Data, mimeType);
+            const written = await state.thread.instance.writeFile(path2, base64Data, mimeType);
             if (written && written.success === false) {
               console.error("[FlowEngine] Generated image write failed:", written.error);
               continue;
             }
             if (image.id) {
-              imagePathMap.set(image.id, path);
+              imagePathMap.set(image.id, path2);
             }
             refs.push({
               id: attachmentId,
               type: "file",
-              path,
+              path: path2,
               name: `generated-${attachmentId}.${ext}`,
               mimeType,
               size: Math.ceil(base64Data.length * 3 / 4)
@@ -10930,9 +10918,9 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
             continue;
           }
           const attachmentId = crypto.randomUUID();
-          const path = `/attachments/${Date.now()}-${attachmentId.slice(0, 8)}.${ext}`;
+          const path2 = `/attachments/${Date.now()}-${attachmentId.slice(0, 8)}.${ext}`;
           try {
-            const written = await state.thread.instance.writeFile(path, base64Data, mimeType);
+            const written = await state.thread.instance.writeFile(path2, base64Data, mimeType);
             if (written && written.success === false) {
               console.error(`[FlowEngine] ${toolName} image write failed:`, written.error);
               continue;
@@ -10940,7 +10928,7 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
             const attachmentRef = {
               id: attachmentId,
               type: "file",
-              path,
+              path: path2,
               name: `generated-${attachmentId}.${ext}`,
               mimeType,
               size: Math.ceil(base64Data.length * 3 / 4)
@@ -11003,7 +10991,7 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
                   content: "Image generated successfully",
                   status: "success",
                   timestamp: Date.now(),
-                  attachment_path: path
+                  attachment_path: path2
                 });
                 await state.storage.sql.exec(
                   `UPDATE logs SET tool_results = ?1 WHERE id = ?2`,
@@ -11025,7 +11013,7 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
               }
             }
             if (image.id) {
-              imagePathMap.set(image.id, path);
+              imagePathMap.set(image.id, path2);
             }
           } catch (error) {
             console.error(`[FlowEngine] Failed to store provider tool result for ${toolName}:`, error);
@@ -11890,7 +11878,7 @@ async function updateThread(thread, params) {
   }
   return result.thread;
 }
-async function writeFile(flow, path, data, mimeType, options) {
+async function writeFile(flow, path2, data, mimeType, options) {
   const instance = flow.thread.instance;
   let base64Data;
   if (typeof data === "string") {
@@ -11912,7 +11900,7 @@ async function writeFile(flow, path, data, mimeType, options) {
     }
     base64Thumbnail = btoa(binary);
   }
-  const result = await instance.writeFile(path, base64Data, mimeType, {
+  const result = await instance.writeFile(path2, base64Data, mimeType, {
     metadata: options?.metadata,
     thumbnail: base64Thumbnail
   });
@@ -11921,20 +11909,20 @@ async function writeFile(flow, path, data, mimeType, options) {
   }
   return result.file;
 }
-async function writeImage(flow, path, data, mimeType, options) {
-  return writeFile(flow, path, data, mimeType, options);
+async function writeImage(flow, path2, data, mimeType, options) {
+  return writeFile(flow, path2, data, mimeType, options);
 }
-async function linkFile(flow, path, location, options) {
+async function linkFile(flow, path2, location, options) {
   const instance = flow.thread.instance;
-  const result = await instance.linkFile(path, location, options);
+  const result = await instance.linkFile(path2, location, options);
   if (!result.success) {
     throw new Error(result.error || "Failed to link file");
   }
   return result.file;
 }
-async function readFile(flow, path) {
+async function readFile(flow, path2) {
   const instance = flow.thread.instance;
-  const result = await instance.readFile(path);
+  const result = await instance.readFile(path2);
   if (!result.success) {
     return null;
   }
@@ -11945,45 +11933,45 @@ async function readFile(flow, path) {
   }
   return bytes.buffer;
 }
-async function stat(flow, path) {
+async function stat(flow, path2) {
   const instance = flow.thread.instance;
-  const result = await instance.statFile(path);
+  const result = await instance.statFile(path2);
   if (!result.success) {
     return null;
   }
   return result.file;
 }
-async function exists(flow, path) {
+async function exists(flow, path2) {
   const instance = flow.thread.instance;
-  const result = await instance.fileExists(path);
+  const result = await instance.fileExists(path2);
   return result.success && result.exists;
 }
-async function unlink(flow, path) {
+async function unlink(flow, path2) {
   const instance = flow.thread.instance;
-  const result = await instance.unlinkFile(path);
+  const result = await instance.unlinkFile(path2);
   if (!result.success) {
     throw new Error(result.error || "Failed to delete file");
   }
 }
-async function mkdir(flow, path) {
+async function mkdir(flow, path2) {
   const instance = flow.thread.instance;
-  const result = await instance.mkdirFile(path);
+  const result = await instance.mkdirFile(path2);
   if (!result.success) {
     throw new Error(result.error || "Failed to create directory");
   }
   return result.directory;
 }
-async function readdir(flow, path) {
+async function readdir(flow, path2) {
   const instance = flow.thread.instance;
-  const result = await instance.readdirFile(path);
+  const result = await instance.readdirFile(path2);
   if (!result.success) {
     throw new Error(result.error || "Failed to read directory");
   }
   return result.files;
 }
-async function rmdir(flow, path) {
+async function rmdir(flow, path2) {
   const instance = flow.thread.instance;
-  const result = await instance.rmdirFile(path);
+  const result = await instance.rmdirFile(path2);
   if (!result.success) {
     throw new Error(result.error || "Failed to remove directory");
   }
@@ -11996,9 +11984,9 @@ async function move(flow, sourcePath, destinationPath) {
   }
   return result.file;
 }
-async function rename(flow, path, newName) {
+async function rename(flow, path2, newName) {
   const instance = flow.thread.instance;
-  const result = await instance.renameFile(path, newName);
+  const result = await instance.renameFile(path2, newName);
   if (!result.success) {
     throw new Error(result.error || "Failed to rename file");
   }
@@ -12012,9 +12000,9 @@ async function getFileStats(flow) {
   }
   return result.stats;
 }
-async function getThumbnail(flow, path) {
+async function getThumbnail(flow, path2) {
   const instance = flow.thread.instance;
-  const result = await instance.getFileThumbnail(path);
+  const result = await instance.getFileThumbnail(path2);
   if (!result.success) {
     return null;
   }
@@ -12025,22 +12013,22 @@ async function getThumbnail(flow, path) {
   }
   return bytes.buffer;
 }
-async function cat(flow, path) {
+async function cat(flow, path2) {
   const instance = flow.thread.instance;
-  const result = await instance.readTextFile(path);
+  const result = await instance.readTextFile(path2);
   if (!result.success) {
     return null;
   }
   return result.content;
 }
-async function head(flow, path, lines = 10) {
-  const content = await cat(flow, path);
+async function head(flow, path2, lines = 10) {
+  const content = await cat(flow, path2);
   if (content === null) return null;
   const allLines = content.split("\n");
   return allLines.slice(0, lines).join("\n");
 }
-async function tail(flow, path, lines = 10) {
-  const content = await cat(flow, path);
+async function tail(flow, path2, lines = 10) {
+  const content = await cat(flow, path2);
   if (content === null) return null;
   const allLines = content.split("\n");
   return allLines.slice(-lines).join("\n");
@@ -12579,32 +12567,32 @@ function prepareBridge(options, reports, logs) {
     logs
   };
 }
-function prepareNamespaceRecord(value, path, functions) {
+function prepareNamespaceRecord(value, path2, functions) {
   const out = {};
   for (const [key, namespace] of Object.entries(value)) {
-    out[key] = prepareValueRecord(namespace, `${path}.${key}`, functions);
+    out[key] = prepareValueRecord(namespace, `${path2}.${key}`, functions);
   }
   return out;
 }
-function prepareValueRecord(value, path, functions) {
+function prepareValueRecord(value, path2, functions) {
   const out = {};
   for (const [key, item] of Object.entries(value)) {
-    out[key] = prepareBridgeValue(item, `${path}.${key}`, functions);
+    out[key] = prepareBridgeValue(item, `${path2}.${key}`, functions);
   }
   return out;
 }
-function prepareBridgeValue(value, path, functions) {
+function prepareBridgeValue(value, path2, functions) {
   if (typeof value === "function") {
-    functions.set(path, value);
-    return { __agentbuilderType: "function", id: path };
+    functions.set(path2, value);
+    return { __agentbuilderType: "function", id: path2 };
   }
   if (isThenable(value)) {
-    const promiseId = `${path}.__promise`;
+    const promiseId = `${path2}.__promise`;
     functions.set(promiseId, async () => value);
     return { __agentbuilderType: "promise", id: promiseId };
   }
   if (Array.isArray(value)) {
-    return value.map((item, index) => prepareBridgeValue(item, `${path}.${index}`, functions));
+    return value.map((item, index) => prepareBridgeValue(item, `${path2}.${index}`, functions));
   }
   if (value && typeof value === "object") {
     if (value instanceof Date || value instanceof Map || value instanceof Set || ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
@@ -12615,7 +12603,7 @@ function prepareBridgeValue(value, path, functions) {
     }
     const out = {};
     for (const [key, item] of Object.entries(value)) {
-      out[key] = prepareBridgeValue(item, `${path}.${key}`, functions);
+      out[key] = prepareBridgeValue(item, `${path2}.${key}`, functions);
     }
     return out;
   }
@@ -13490,12 +13478,12 @@ function normalizeVirtualModulePath(basePath, specifier) {
   }
   return normalized;
 }
-function dirnameModulePath(path) {
-  const index = path.lastIndexOf("/");
-  return index <= 0 ? "" : path.slice(0, index);
+function dirnameModulePath(path2) {
+  const index = path2.lastIndexOf("/");
+  return index <= 0 ? "" : path2.slice(0, index);
 }
-function hasModuleExtension(path) {
-  return /\.[A-Za-z0-9]+$/.test(path);
+function hasModuleExtension(path2) {
+  return /\.[A-Za-z0-9]+$/.test(path2);
 }
 function resolveGraphModuleSpecifier(fromPath, specifier, modulePaths) {
   const base = normalizeVirtualModulePath(dirnameModulePath(fromPath), specifier);
@@ -13852,9 +13840,9 @@ function isPlainObject2(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function findUntransferableOption(value, path, seen = /* @__PURE__ */ new WeakSet()) {
+function findUntransferableOption(value, path2, seen = /* @__PURE__ */ new WeakSet()) {
   if (typeof value === "function" || typeof value === "symbol") {
-    return path;
+    return path2;
   }
   if (!value || typeof value !== "object") {
     return null;
@@ -13868,7 +13856,7 @@ function findUntransferableOption(value, path, seen = /* @__PURE__ */ new WeakSe
   seen.add(value);
   if (Array.isArray(value)) {
     for (const [index, item] of value.entries()) {
-      const found = findUntransferableOption(item, `${path}.${index}`, seen);
+      const found = findUntransferableOption(item, `${path2}.${index}`, seen);
       if (found) return found;
     }
     return null;
@@ -13876,9 +13864,9 @@ function findUntransferableOption(value, path, seen = /* @__PURE__ */ new WeakSe
   if (value instanceof Map) {
     let index = 0;
     for (const [key, item] of value.entries()) {
-      const foundKey = findUntransferableOption(key, `${path}.mapKey${index}`, seen);
+      const foundKey = findUntransferableOption(key, `${path2}.mapKey${index}`, seen);
       if (foundKey) return foundKey;
-      const foundValue = findUntransferableOption(item, `${path}.mapValue${index}`, seen);
+      const foundValue = findUntransferableOption(item, `${path2}.mapValue${index}`, seen);
       if (foundValue) return foundValue;
       index += 1;
     }
@@ -13887,17 +13875,17 @@ function findUntransferableOption(value, path, seen = /* @__PURE__ */ new WeakSe
   if (value instanceof Set) {
     let index = 0;
     for (const item of value.values()) {
-      const found = findUntransferableOption(item, `${path}.setValue${index}`, seen);
+      const found = findUntransferableOption(item, `${path2}.setValue${index}`, seen);
       if (found) return found;
       index += 1;
     }
     return null;
   }
   if (!isPlainObject2(value)) {
-    return path;
+    return path2;
   }
   for (const [key, item] of Object.entries(value)) {
-    const found = findUntransferableOption(item, `${path}.${key}`, seen);
+    const found = findUntransferableOption(item, `${path2}.${key}`, seen);
     if (found) return found;
   }
   return null;
@@ -14873,7 +14861,7 @@ var init_ThreadStateImpl = __esm({
       // ─────────────────────────────────────────────────────────────────────────
       // File System
       // ─────────────────────────────────────────────────────────────────────────
-      async writeFile(path, data, mimeType, options) {
+      async writeFile(path2, data, mimeType, options) {
         const isText = this._isTextMimeType(mimeType);
         if (isText) {
           let textContent;
@@ -14882,7 +14870,7 @@ var init_ThreadStateImpl = __esm({
           } else {
             textContent = new TextDecoder().decode(data);
           }
-          const result = await this._threadInstance.writeTextFile(path, textContent, mimeType, options);
+          const result = await this._threadInstance.writeTextFile(path2, textContent, mimeType, options);
           return this._mapFileRecord(result.file);
         } else {
           let base64Data;
@@ -14902,7 +14890,7 @@ var init_ThreadStateImpl = __esm({
             }
             base64Data = btoa(binary);
           }
-          const result = await this._threadInstance.writeFile(path, base64Data, mimeType, options);
+          const result = await this._threadInstance.writeFile(path2, base64Data, mimeType, options);
           return this._mapFileRecord(result.file);
         }
       }
@@ -14974,8 +14962,8 @@ var init_ThreadStateImpl = __esm({
           (type) => mimeType === type || mimeType.startsWith(type + ";")
         );
       }
-      async readFile(path) {
-        const result = await this._threadInstance.readFile(path);
+      async readFile(path2) {
+        const result = await this._threadInstance.readFile(path2);
         if (!result.success || !result.data) {
           return null;
         }
@@ -14986,8 +14974,8 @@ var init_ThreadStateImpl = __esm({
         }
         return bytes.buffer;
       }
-      async readFileStream(path, options) {
-        const fileInfo = this._unwrapStatRecord(await this._threadInstance.statFile(path));
+      async readFileStream(path2, options) {
+        const fileInfo = this._unwrapStatRecord(await this._threadInstance.statFile(path2));
         if (!fileInfo) {
           return null;
         }
@@ -15002,7 +14990,7 @@ var init_ThreadStateImpl = __esm({
         return {
           [Symbol.asyncIterator]: async function* () {
             if (!isChunked) {
-              const result = await threadInstance.readFile(path);
+              const result = await threadInstance.readFile(path2);
               if (!result.success || !result.data) {
                 return;
               }
@@ -15023,7 +15011,7 @@ var init_ThreadStateImpl = __esm({
               if (signal?.aborted) {
                 return;
               }
-              const result = await threadInstance.readFileChunk(path, i);
+              const result = await threadInstance.readFileChunk(path2, i);
               if (!result.success || !result.data) {
                 throw new Error(result.error || `Failed to read chunk ${i}`);
               }
@@ -15056,31 +15044,31 @@ var init_ThreadStateImpl = __esm({
         if (!("path" in record) && !("name" in record)) return null;
         return record;
       }
-      async statFile(path) {
-        const record = this._unwrapStatRecord(await this._threadInstance.statFile(path));
+      async statFile(path2) {
+        const record = this._unwrapStatRecord(await this._threadInstance.statFile(path2));
         return record ? this._mapFileRecord(record) : null;
       }
-      async readdirFile(path) {
-        const result = await this._threadInstance.readdirFile(path);
+      async readdirFile(path2) {
+        const result = await this._threadInstance.readdirFile(path2);
         const entries = Array.isArray(result) ? result : result?.files;
         if (!Array.isArray(entries)) {
           throw new Error(
-            result?.error || `Could not list directory: ${path}`
+            result?.error || `Could not list directory: ${path2}`
           );
         }
         return {
           entries: entries.map((e) => this._mapFileRecord(e))
         };
       }
-      async unlinkFile(path) {
-        await this._threadInstance.unlinkFile(path);
+      async unlinkFile(path2) {
+        await this._threadInstance.unlinkFile(path2);
       }
-      async mkdirFile(path) {
-        const result = await this._threadInstance.mkdirFile(path);
+      async mkdirFile(path2) {
+        const result = await this._threadInstance.mkdirFile(path2);
         return this._mapFileRecord(result);
       }
-      async rmdirFile(path) {
-        await this._threadInstance.rmdirFile(path);
+      async rmdirFile(path2) {
+        await this._threadInstance.rmdirFile(path2);
       }
       async moveFile(sourcePath, destinationPath) {
         const result = await this._threadInstance.moveFile(sourcePath, destinationPath);
@@ -15089,8 +15077,8 @@ var init_ThreadStateImpl = __esm({
         }
         return this._mapFileRecord(result.file);
       }
-      async renameFile(path, newName) {
-        const result = await this._threadInstance.renameFile(path, newName);
+      async renameFile(path2, newName) {
+        const result = await this._threadInstance.renameFile(path2, newName);
         if (!result.success || !result.file) {
           throw new Error(result.error || "Failed to rename file");
         }
@@ -15117,8 +15105,8 @@ var init_ThreadStateImpl = __esm({
           paths: Array.isArray(results) ? results : results.paths || []
         };
       }
-      async getFileThumbnail(path) {
-        return this._threadInstance.getFileThumbnail(path);
+      async getFileThumbnail(path2) {
+        return this._threadInstance.getFileThumbnail(path2);
       }
       // ─────────────────────────────────────────────────────────────────────────
       // Execution State
@@ -15423,7 +15411,7 @@ var init_ThreadStateImpl = __esm({
             const skillMd = await stub.getSkillFile(scope, name, "SKILL.md") ?? "";
             return { metadata, skillMd };
           },
-          readFile: (name, path) => stub.getSkillFile(scope, name, path),
+          readFile: (name, path2) => stub.getSkillFile(scope, name, path2),
           install: async (files) => {
             await requireMutationAdmin();
             return stub.upsertSkill(scope, files);
@@ -15710,7 +15698,14 @@ function isHostedInstance(env) {
   }
   return Boolean(value);
 }
-function isTrustedLocalDevelopmentRequest(request, env) {
+function compiledTrustedDevHosts() {
+  try {
+    return typeof __STANDARD_AGENTS_TRUSTED_DEV_HOSTS__ !== "undefined" && Array.isArray(__STANDARD_AGENTS_TRUSTED_DEV_HOSTS__) ? __STANDARD_AGENTS_TRUSTED_DEV_HOSTS__ : [];
+  } catch {
+    return [];
+  }
+}
+function isTrustedLocalDevelopmentRequest(request, env, trustedDevHosts = compiledTrustedDevHosts()) {
   if (isHostedInstance(env)) return false;
   let hostname;
   try {
@@ -15718,7 +15713,7 @@ function isTrustedLocalDevelopmentRequest(request, env) {
   } catch {
     return false;
   }
-  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.endsWith(".localhost") || hostname.endsWith(".orb.local");
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.endsWith(".localhost") || hostname.endsWith(".orb.local") || trustedDevHosts.some((trusted) => trusted.trim().toLowerCase() === hostname);
 }
 function isPublicApiRoute(routePath, request, env) {
   if (PUBLIC_ROUTES.has(routePath)) return true;
@@ -19013,10 +19008,10 @@ var DurableAgentBuilder = class extends DurableObject {
     for (const entry of value) {
       if (!entry || typeof entry !== "object") continue;
       const attachment = entry;
-      const path = typeof attachment.path === "string" ? attachment.path.trim() : "";
-      if (!path) continue;
+      const path2 = typeof attachment.path === "string" ? attachment.path.trim() : "";
+      if (!path2) continue;
       output.push({
-        path,
+        path: path2,
         name: typeof attachment.name === "string" ? attachment.name : void 0,
         mimeType: typeof attachment.mimeType === "string" ? attachment.mimeType : void 0,
         size: typeof attachment.size === "number" ? attachment.size : void 0,
@@ -19033,8 +19028,8 @@ var DurableAgentBuilder = class extends DurableObject {
     const trimmed = sanitized.replace(/^[-.]+|[-.]+$/g, "");
     return trimmed || "attachment";
   }
-  inferMimeTypeFromPath(path) {
-    const normalized = path.toLowerCase();
+  inferMimeTypeFromPath(path2) {
+    const normalized = path2.toLowerCase();
     if (normalized.endsWith(".png")) return "image/png";
     if (normalized.endsWith(".jpg") || normalized.endsWith(".jpeg")) return "image/jpeg";
     if (normalized.endsWith(".webp")) return "image/webp";
@@ -19072,7 +19067,7 @@ var DurableAgentBuilder = class extends DurableObject {
     if (!attachments || attachments.length === 0) {
       return "";
     }
-    const paths = attachments.map((attachment) => attachment.path).filter((path) => typeof path === "string" && path.length > 0);
+    const paths = attachments.map((attachment) => attachment.path).filter((path2) => typeof path2 === "string" && path2.length > 0);
     if (paths.length === 0) {
       return "";
     }
@@ -20474,12 +20469,9 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
             await parentThread.updateChildRegistryStatus(
               params.parent_thread_id,
               childThread.id,
-              childResult.terminal ? "terminated" : "idle"
+              "idle"
             );
           }
-          if (childResult.terminal && typeof childThreadStub.terminateThread === "function") {
-            await childThreadStub.terminateThread(childThread.id);
-          }
         } else if (typeof childThreadStub.terminateThread === "function") {
           await childThreadStub.terminateThread(childThread.id);
         }
@@ -21752,7 +21744,7 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
     for (const row of cursor.toArray()) {
       if (skills.has(row.name)) continue;
       const parsedFiles = row.files ? JSON.parse(row.files) : [];
-      const files = Array.isArray(parsedFiles) ? parsedFiles.filter((path) => typeof path === "string").sort() : [];
+      const files = Array.isArray(parsedFiles) ? parsedFiles.filter((path2) => typeof path2 === "string").sort() : [];
       skills.set(row.name, {
         name: row.name,
         description: row.description,
@@ -21770,7 +21762,7 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
     return all.find((s) => s.name === name) ?? null;
   }
   /** One bundled file's text (null when the skill or file is missing). */
-  async getSkillFile(scope, name, path) {
+  async getSkillFile(scope, name, path2) {
     await this.ensureMigrated();
     const cursor = await this.ctx.storage.sql.exec(
       `SELECT f.content FROM skill_files f
@@ -21780,7 +21772,7 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
        ORDER BY CASE WHEN f.owner_id = ? THEN 0 ELSE 1 END
        LIMIT 1`,
       name,
-      path.replace(/^\.\//, ""),
+      path2.replace(/^\.\//, ""),
       scope.ownerId,
       scope.includeShared ? 1 : 0,
       scope.ownerId
@@ -22075,12 +22067,12 @@ async function authorizesToolDelivery(pending, proof) {
   return matchesToolDeliveryOwner(pending, proof) && await matchesToolDeliveryToken(pending.delivery_token_hash, proof.token);
 }
 var RUNTIME_STORAGE_PREFIX = "__agentbuilder_runtime_storage__:";
-function normalizeEndpointThreadPath(path) {
-  if (!path || /^[A-Za-z][A-Za-z\d+\-.]*:/.test(path)) {
+function normalizeEndpointThreadPath(path2) {
+  if (!path2 || /^[A-Za-z][A-Za-z\d+\-.]*:/.test(path2)) {
     throw new Error("Use a relative thread filesystem path");
   }
   const parts = [];
-  for (const part of path.replace(/\\/g, "/").split("/")) {
+  for (const part of path2.replace(/\\/g, "/").split("/")) {
     if (!part || part === ".") continue;
     if (part === "..") {
       if (parts.length === 0) throw new Error("Path cannot escape the thread filesystem root");
@@ -22130,12 +22122,12 @@ function createEndpointFetchBridge() {
 function createEndpointFsBridge(state) {
   const decoder = new TextDecoder();
   return {
-    readFile: async (path) => {
-      const data = await state.readFile(normalizeEndpointThreadPath(path));
+    readFile: async (path2) => {
+      const data = await state.readFile(normalizeEndpointThreadPath(path2));
       return data ? decoder.decode(data) : null;
     },
-    writeFile: async (path, content, mimeType = "text/plain") => {
-      return state.writeFile(normalizeEndpointThreadPath(path), content, mimeType);
+    writeFile: async (path2, content, mimeType = "text/plain") => {
+      return state.writeFile(normalizeEndpointThreadPath(path2), content, mimeType);
     }
   };
 }
@@ -22204,24 +22196,24 @@ function createEndpointThreadStateBridge(state) {
     emit: (event, data) => state.emit(event, data),
     getValue: (key) => state.getValue(key),
     setValue: (key, value) => state.setValue(key, value),
-    readFile: (path) => state.readFile(normalizeEndpointThreadPath(path)),
-    writeFile: (path, data, mimeType = "application/octet-stream", options) => {
-      return state.writeFile(normalizeEndpointThreadPath(path), data, mimeType, options);
+    readFile: (path2) => state.readFile(normalizeEndpointThreadPath(path2)),
+    writeFile: (path2, data, mimeType = "application/octet-stream", options) => {
+      return state.writeFile(normalizeEndpointThreadPath(path2), data, mimeType, options);
     },
-    statFile: (path) => state.statFile(normalizeEndpointThreadPath(path)),
-    readdirFile: (path) => state.readdirFile(normalizeEndpointThreadPath(path)),
-    unlinkFile: (path) => state.unlinkFile(normalizeEndpointThreadPath(path)),
-    mkdirFile: (path) => state.mkdirFile(normalizeEndpointThreadPath(path)),
-    rmdirFile: (path) => state.rmdirFile(normalizeEndpointThreadPath(path)),
+    statFile: (path2) => state.statFile(normalizeEndpointThreadPath(path2)),
+    readdirFile: (path2) => state.readdirFile(normalizeEndpointThreadPath(path2)),
+    unlinkFile: (path2) => state.unlinkFile(normalizeEndpointThreadPath(path2)),
+    mkdirFile: (path2) => state.mkdirFile(normalizeEndpointThreadPath(path2)),
+    rmdirFile: (path2) => state.rmdirFile(normalizeEndpointThreadPath(path2)),
     moveFile: (sourcePath, destinationPath) => state.moveFile(
       normalizeEndpointThreadPath(sourcePath),
       normalizeEndpointThreadPath(destinationPath)
     ),
-    renameFile: (path, newName) => state.renameFile(normalizeEndpointThreadPath(path), newName),
+    renameFile: (path2, newName) => state.renameFile(normalizeEndpointThreadPath(path2), newName),
     getFileStats: () => state.getFileStats(),
     grepFiles: (pattern) => state.grepFiles(pattern),
     findFiles: (pattern) => state.findFiles(pattern),
-    getFileThumbnail: (path) => state.getFileThumbnail(normalizeEndpointThreadPath(path))
+    getFileThumbnail: (path2) => state.getFileThumbnail(normalizeEndpointThreadPath(path2))
   };
 }
 function routeBridgeClientFrame(socket, message, handlers) {
@@ -22973,7 +22965,7 @@ var DurableThread = class _DurableThread extends DurableObject {
     this.assertJsonSerializableThreadValue(value, "$", /* @__PURE__ */ new WeakSet());
     return JSON.stringify(value);
   }
-  assertJsonSerializableThreadValue(value, path, seen) {
+  assertJsonSerializableThreadValue(value, path2, seen) {
     if (value === null) {
       return;
     }
@@ -22983,36 +22975,36 @@ var DurableThread = class _DurableThread extends DurableObject {
         return;
       case "number":
         if (!Number.isFinite(value)) {
-          throw new Error(`Thread value at ${path} must be a finite number`);
+          throw new Error(`Thread value at ${path2} must be a finite number`);
         }
         return;
       case "object": {
         if (seen.has(value)) {
-          throw new Error(`Thread value at ${path} cannot contain circular references`);
+          throw new Error(`Thread value at ${path2} cannot contain circular references`);
         }
         seen.add(value);
         if (Array.isArray(value)) {
           for (let i = 0; i < value.length; i += 1) {
-            this.assertJsonSerializableThreadValue(value[i], `${path}[${i}]`, seen);
+            this.assertJsonSerializableThreadValue(value[i], `${path2}[${i}]`, seen);
           }
           seen.delete(value);
           return;
         }
         const prototype = Object.getPrototypeOf(value);
         if (prototype !== Object.prototype && prototype !== null) {
-          throw new Error(`Thread value at ${path} must be a JSON object, array, or primitive`);
+          throw new Error(`Thread value at ${path2} must be a JSON object, array, or primitive`);
         }
         if (Object.getOwnPropertySymbols(value).length > 0) {
-          throw new Error(`Thread value at ${path} cannot contain symbol keys`);
+          throw new Error(`Thread value at ${path2} cannot contain symbol keys`);
         }
         for (const [entryKey, entryValue] of Object.entries(value)) {
-          this.assertJsonSerializableThreadValue(entryValue, `${path}.${entryKey}`, seen);
+          this.assertJsonSerializableThreadValue(entryValue, `${path2}.${entryKey}`, seen);
         }
         seen.delete(value);
         return;
       }
       default:
-        throw new Error(`Thread value at ${path} must be JSON-serializable`);
+        throw new Error(`Thread value at ${path2} must be JSON-serializable`);
     }
   }
   // ============================================================
@@ -24213,8 +24205,8 @@ var DurableThread = class _DurableThread extends DurableObject {
     );
     return terminalCursor.toArray()[0] ?? null;
   }
-  inferMimeTypeFromPath(path) {
-    const normalized = path.toLowerCase();
+  inferMimeTypeFromPath(path2) {
+    const normalized = path2.toLowerCase();
     if (normalized.endsWith(".png")) return "image/png";
     if (normalized.endsWith(".jpg") || normalized.endsWith(".jpeg")) return "image/jpeg";
     if (normalized.endsWith(".webp")) return "image/webp";
@@ -24253,7 +24245,7 @@ var DurableThread = class _DurableThread extends DurableObject {
       ext: value.slice(lastDot + 1).toLowerCase()
     };
   }
-  resolveAttachmentMimeType(sourceMimeType, fallbackMimeType, path) {
+  resolveAttachmentMimeType(sourceMimeType, fallbackMimeType, path2) {
     const source = sourceMimeType?.trim();
     if (source && source !== "application/octet-stream") {
       return source;
@@ -24262,7 +24254,7 @@ var DurableThread = class _DurableThread extends DurableObject {
     if (fallback && fallback !== "application/octet-stream") {
       return fallback;
     }
-    return this.inferMimeTypeFromPath(path) ?? source ?? fallback ?? "application/octet-stream";
+    return this.inferMimeTypeFromPath(path2) ?? source ?? fallback ?? "application/octet-stream";
   }
   buildAttachmentTargetPath(preferredName, mimeType, sourcePath) {
     const safeName = this.sanitizeFilename(preferredName);
@@ -24357,8 +24349,8 @@ var DurableThread = class _DurableThread extends DurableObject {
     }
     return copied;
   }
-  async readAttachmentDataFromSource(path, sourceFile) {
-    const sourceData = await this.readFile(path);
+  async readAttachmentDataFromSource(path2, sourceFile) {
+    const sourceData = await this.readFile(path2);
     if (sourceData.success && sourceData.data) {
       return sourceData.data;
     }
@@ -24395,7 +24387,7 @@ var DurableThread = class _DurableThread extends DurableObject {
     if (!attachments || attachments.length === 0) {
       return "";
     }
-    const paths = attachments.map((attachment) => attachment.path).filter((path) => typeof path === "string" && path.length > 0);
+    const paths = attachments.map((attachment) => attachment.path).filter((path2) => typeof path2 === "string" && path2.length > 0);
     if (paths.length === 0) {
       return "";
     }
@@ -24475,11 +24467,13 @@ ${paths.join("\n")}`;
     try {
       const parentId = this.env.AGENT_BUILDER_THREAD.idFromName(parentThreadId);
       const parentStub = this.env.AGENT_BUILDER_THREAD.get(parentId);
-      const parentCommunication = await this.getParentCommunicationModeForChild(
+      const childRegistryEntry = await this.getParentRegistryEntryForChild(
         parentStub,
         parentThreadId,
         threadId
       );
+      const parentCommunication = childRegistryEntry?.parentCommunication === "explicit" ? "explicit" : "implicit";
+      const resumableChild = childRegistryEntry?.resumable === true;
       const copiedRefs = await this.copyAttachmentRefsToThread(
         refs,
         parentStub,
@@ -24502,10 +24496,11 @@ ${resultContent}${attachmentSummary}`;
         });
       }
       const terminalChildRun = sessionStopped || hasTerminalSessionTools;
+      const terminateChildThread = terminalChildRun && !resumableChild;
       await parentStub.updateChildRegistryStatus(
         parentThreadId,
         threadId,
-        terminalChildRun ? "terminated" : "idle"
+        terminateChildThread ? "terminated" : "idle"
       );
       if (parentCommunication !== "explicit") {
         await this.persistParentHandoffStatusMessage(
@@ -24513,23 +24508,22 @@ ${resultContent}${attachmentSummary}`;
           isErrorTerminal ? "failure" : "result"
         );
       }
-      if (terminalChildRun) {
+      if (terminateChildThread) {
         await this.terminateThread(threadId);
       }
     } catch (error) {
       console.error("[DurableThread] Failed to deliver subagent completion to parent:", error);
     }
   }
-  async getParentCommunicationModeForChild(parentStub, parentThreadId, childThreadId) {
+  async getParentRegistryEntryForChild(parentStub, parentThreadId, childThreadId) {
     if (typeof parentStub.getChildrenRegistry !== "function") {
-      return "implicit";
+      return void 0;
     }
     try {
       const entries = await parentStub.getChildrenRegistry(parentThreadId);
-      const childEntry = entries.find((entry) => entry.reference === childThreadId);
-      return childEntry?.parentCommunication === "explicit" ? "explicit" : "implicit";
+      return entries.find((entry) => entry.reference === childThreadId);
     } catch {
-      return "implicit";
+      return void 0;
     }
   }
   /**
@@ -26077,7 +26071,7 @@ ${resultContent}${attachmentSummary}`;
           void 0,
           INTERNAL_TOOL_DELIVERY
         );
-        if (delivered?.resume) sides.add(delivered.side);
+        if (delivered) sides.add(delivered.side);
       }
       if (threadId) {
         for (const side of sides) {
@@ -26379,17 +26373,14 @@ ${resultContent}${attachmentSummary}`;
   deliveredResultWaiters = /* @__PURE__ */ new Map();
   notifyDeliveredResultWaiters(toolCallId) {
     const waiters = this.deliveredResultWaiters?.get(toolCallId);
-    if (!waiters || waiters.size === 0) return false;
+    if (!waiters) return;
     this.deliveredResultWaiters.delete(toolCallId);
-    let notified = false;
     for (const wake of waiters) {
       try {
         wake();
-        notified = true;
       } catch {
       }
     }
-    return notified;
   }
   /**
    * Await a parked forwarded call's delivered result: one immediate read,
@@ -26534,46 +26525,37 @@ ${resultContent}${attachmentSummary}`;
     const side = pending.side === "b" ? "b" : "a";
     const content = ok ? result ?? "" : `Error: ${error ?? "tool failed"}`;
     const toolStatus = ok ? "success" : "error";
-    const resultMessageId = crypto.randomUUID();
-    const resultCreatedAt = Date.now() * TIMESTAMP_MULTIPLIER;
-    const accepted = this.ctx.storage.transactionSync(() => {
-      const claimed = this.ctx.storage.sql.exec(
-        `UPDATE pending_client_calls
-            SET status = 'resolved'
-          WHERE tool_call_id = ? AND status = 'pending'`,
+    await this.ctx.storage.sql.exec(
+      `UPDATE messages SET content = ?, tool_status = ? WHERE tool_call_id = ? AND role = 'tool'`,
+      content,
+      toolStatus,
+      toolCallId
+    );
+    const updated = await this.ctx.storage.sql.exec(
+      `SELECT COUNT(*) AS total FROM messages WHERE tool_call_id = ? AND role = 'tool'`,
+      toolCallId
+    );
+    if (Number(updated.toArray()[0]?.total ?? 0) === 0) {
+      const toolRow = await this.ctx.storage.sql.exec(
+        `SELECT tool FROM pending_client_calls WHERE tool_call_id = ? LIMIT 1`,
         toolCallId
       );
-      if (claimed.rowsWritten !== 1) return false;
-      this.ctx.storage.sql.exec(
-        `UPDATE messages SET content = ?, tool_status = ? WHERE tool_call_id = ? AND role = 'tool'`,
+      await this.ctx.storage.sql.exec(
+        `INSERT INTO messages (id, role, content, name, tool_call_id, tool_status, created_at, status, prompt)
+         VALUES (?, 'tool', ?, ?, ?, ?, ?, 'completed', NULL)`,
+        crypto.randomUUID(),
         content,
+        toolRow.toArray()[0]?.tool ?? null,
+        toolCallId,
         toolStatus,
-        toolCallId
+        Date.now() * TIMESTAMP_MULTIPLIER
       );
-      const updated = this.ctx.storage.sql.exec(
-        `SELECT COUNT(*) AS total FROM messages WHERE tool_call_id = ? AND role = 'tool'`,
-        toolCallId
-      );
-      if (Number(updated.toArray()[0]?.total ?? 0) === 0) {
-        const toolRow = this.ctx.storage.sql.exec(
-          `SELECT tool FROM pending_client_calls WHERE tool_call_id = ? LIMIT 1`,
-          toolCallId
-        );
-        this.ctx.storage.sql.exec(
-          `INSERT INTO messages (id, role, content, name, tool_call_id, tool_status, created_at, status, prompt)
-           VALUES (?, 'tool', ?, ?, ?, ?, ?, 'completed', NULL)`,
-          resultMessageId,
-          content,
-          toolRow.toArray()[0]?.tool ?? null,
-          toolCallId,
-          toolStatus,
-          resultCreatedAt
-        );
-      }
-      return true;
-    });
-    if (!accepted) return null;
-    const resumedInline = this.notifyDeliveredResultWaiters(toolCallId);
+    }
+    await this.ctx.storage.sql.exec(
+      `UPDATE pending_client_calls SET status = 'resolved' WHERE tool_call_id = ?`,
+      toolCallId
+    );
+    this.notifyDeliveredResultWaiters(toolCallId);
     try {
       const msgCursor = await this.ctx.storage.sql.exec(
         `SELECT id, role, content, name, tool_call_id, tool_status, created_at, depth
@@ -26584,7 +26566,7 @@ ${resultContent}${attachmentSummary}`;
       if (msg) this.broadcastMessage(msg);
     } catch {
     }
-    return { side, resume: !resumedInline };
+    return { side };
   }
   // ─── Runtime byte streams ──────────────────────────────────────────────────
   // The existing bridge frames carry opaque capability metadata and bytes
@@ -27758,11 +27740,12 @@ ${resultContent}${attachmentSummary}`;
       if (!parentThreadId) return;
       const parentId = this.env.AGENT_BUILDER_THREAD.idFromName(parentThreadId);
       const parentStub = this.env.AGENT_BUILDER_THREAD.get(parentId);
-      const parentCommunication = await this.getParentCommunicationModeForChild(
+      const childRegistryEntry = await this.getParentRegistryEntryForChild(
         parentStub,
         parentThreadId,
         threadId
       );
+      const parentCommunication = childRegistryEntry?.parentCommunication === "explicit" ? "explicit" : "implicit";
       if (parentCommunication !== "explicit") {
         await parentStub.queueMessage(parentThreadId, {
           role: "user",
@@ -28521,11 +28504,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Write a file to storage (RPC method)
    */
-  async writeFile(path, data, mimeType, options) {
+  async writeFile(path2, data, mimeType, options) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const existingFile = await fs.stat(path);
+      const fs2 = this.getFileStorage();
+      const existingFile = await fs2.stat(path2);
       const isUpdate = existingFile !== null;
       const binaryString = atob(data);
       const dataBuffer = new Uint8Array(binaryString.length);
@@ -28547,12 +28530,12 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
           }
         }
       }
-      const record = await fs.writeFile(path, dataBuffer, mimeType, {
+      const record = await fs2.writeFile(path2, dataBuffer, mimeType, {
         metadata: options?.metadata,
         thumbnail: thumbnailBuffer
       });
       this.broadcastEvent(isUpdate ? "file_updated" : "file_created", {
-        path,
+        path: path2,
         file: record
       });
       return { success: true, file: record };
@@ -28564,15 +28547,15 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Write a text file to storage (RPC method)
    */
-  async writeTextFile(path, content, mimeType = "text/plain", options) {
+  async writeTextFile(path2, content, mimeType = "text/plain", options) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const existingFile = await fs.stat(path);
+      const fs2 = this.getFileStorage();
+      const existingFile = await fs2.stat(path2);
       const isUpdate = existingFile !== null;
-      const record = await fs.writeFile(path, content, mimeType, options);
+      const record = await fs2.writeFile(path2, content, mimeType, options);
       this.broadcastEvent(isUpdate ? "file_updated" : "file_created", {
-        path,
+        path: path2,
         file: record
       });
       return { success: true, file: record };
@@ -28609,11 +28592,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Link to an external file (RPC method)
    */
-  async linkFile(path, location, options) {
+  async linkFile(path2, location, options) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const record = await fs.linkFile(path, location, options);
+      const fs2 = this.getFileStorage();
+      const record = await fs2.linkFile(path2, location, options);
       return { success: true, file: record };
     } catch (error) {
       console.error("Error in linkFile:", error);
@@ -28624,11 +28607,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    * Read a file from storage (RPC method)
    * Returns base64-encoded data
    */
-  async readFile(path) {
+  async readFile(path2) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const data = await fs.readFile(path);
+      const fs2 = this.getFileStorage();
+      const data = await fs2.readFile(path2);
       if (data === null) {
         return { success: false, error: "File not found or external" };
       }
@@ -28647,11 +28630,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Read a text file from storage (RPC method)
    */
-  async readTextFile(path) {
+  async readTextFile(path2) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const content = await fs.readTextFile(path);
+      const fs2 = this.getFileStorage();
+      const content = await fs2.readTextFile(path2);
       if (content === null) {
         return { success: false, error: "File not found or external" };
       }
@@ -28664,11 +28647,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Get file metadata (RPC method)
    */
-  async statFile(path) {
+  async statFile(path2) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const record = await fs.stat(path);
+      const fs2 = this.getFileStorage();
+      const record = await fs2.stat(path2);
       if (record === null) {
         return { success: false, error: "File not found" };
       }
@@ -28681,11 +28664,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Check if file exists (RPC method)
    */
-  async fileExists(path) {
+  async fileExists(path2) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const exists2 = await fs.exists(path);
+      const fs2 = this.getFileStorage();
+      const exists2 = await fs2.exists(path2);
       return { success: true, exists: exists2 };
     } catch (error) {
       console.error("Error in fileExists:", error);
@@ -28695,12 +28678,12 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Delete a file (RPC method)
    */
-  async unlinkFile(path) {
+  async unlinkFile(path2) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      await fs.unlink(path);
-      this.broadcastEvent("file_deleted", { path });
+      const fs2 = this.getFileStorage();
+      await fs2.unlink(path2);
+      this.broadcastEvent("file_deleted", { path: path2 });
       return { success: true };
     } catch (error) {
       console.error("Error in unlinkFile:", error);
@@ -28710,12 +28693,12 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Create a directory (RPC method)
    */
-  async mkdirFile(path) {
+  async mkdirFile(path2) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const record = await fs.mkdir(path);
-      this.broadcastEvent("file_created", { path, file: record });
+      const fs2 = this.getFileStorage();
+      const record = await fs2.mkdir(path2);
+      this.broadcastEvent("file_created", { path: path2, file: record });
       return { success: true, directory: record };
     } catch (error) {
       console.error("Error in mkdirFile:", error);
@@ -28725,11 +28708,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * List directory contents (RPC method)
    */
-  async readdirFile(path) {
+  async readdirFile(path2) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const files = await fs.readdir(path);
+      const fs2 = this.getFileStorage();
+      const files = await fs2.readdir(path2);
       return { success: true, files };
     } catch (error) {
       console.error("Error in readdirFile:", error);
@@ -28739,12 +28722,12 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Remove empty directory (RPC method)
    */
-  async rmdirFile(path) {
+  async rmdirFile(path2) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      await fs.rmdir(path);
-      this.broadcastEvent("file_deleted", { path });
+      const fs2 = this.getFileStorage();
+      await fs2.rmdir(path2);
+      this.broadcastEvent("file_deleted", { path: path2 });
       return { success: true };
     } catch (error) {
       console.error("Error in rmdirFile:", error);
@@ -28759,9 +28742,9 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
     await this.ensureMigrated();
     try {
       const { normalizePath: normalizePath2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const fs = this.getFileStorage();
+      const fs2 = this.getFileStorage();
       const from = normalizePath2(sourcePath);
-      const record = await fs.move(sourcePath, destinationPath);
+      const record = await fs2.move(sourcePath, destinationPath);
       this.broadcastEvent("file_moved", { from, path: record.path, file: record });
       this.broadcastEvent("file_deleted", { path: from });
       this.broadcastEvent("file_created", { path: record.path, file: record });
@@ -28774,13 +28757,13 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Rename a file or directory in place (RPC method).
    */
-  async renameFile(path, newName) {
+  async renameFile(path2, newName) {
     await this.ensureMigrated();
     try {
       const { normalizePath: normalizePath2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const fs = this.getFileStorage();
-      const from = normalizePath2(path);
-      const record = await fs.rename(path, newName);
+      const fs2 = this.getFileStorage();
+      const from = normalizePath2(path2);
+      const record = await fs2.rename(path2, newName);
       this.broadcastEvent("file_moved", { from, path: record.path, file: record });
       this.broadcastEvent("file_deleted", { path: from });
       this.broadcastEvent("file_created", { path: record.path, file: record });
@@ -28796,8 +28779,8 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   async getFileStats() {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const stats = await fs.getFileStats();
+      const fs2 = this.getFileStorage();
+      const stats = await fs2.getFileStats();
       return { success: true, stats };
     } catch (error) {
       console.error("Error in getFileStats:", error);
@@ -28808,11 +28791,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    * Get thumbnail for an image (RPC method)
    * Returns base64-encoded data
    */
-  async getFileThumbnail(path) {
+  async getFileThumbnail(path2) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const data = await fs.getThumbnail(path);
+      const fs2 = this.getFileStorage();
+      const data = await fs2.getThumbnail(path2);
       if (data === null) {
         return { success: false, error: "Thumbnail not found" };
       }
@@ -28834,8 +28817,8 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   async grepFiles(pattern, options) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const results = await fs.grep(pattern, options);
+      const fs2 = this.getFileStorage();
+      const results = await fs2.grep(pattern, options);
       return { success: true, results };
     } catch (error) {
       console.error("Error in grepFiles:", error);
@@ -28848,8 +28831,8 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   async findFiles(pattern, options) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const files = await fs.find(pattern, options);
+      const fs2 = this.getFileStorage();
+      const files = await fs2.find(pattern, options);
       return { success: true, files };
     } catch (error) {
       console.error("Error in findFiles:", error);
@@ -28864,11 +28847,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    * Creates file record with is_chunked=1 and chunk_count=null.
    * Caller should then use writeFileChunk() to write chunks.
    */
-  async startChunkedUpload(path, totalSize, mimeType, options) {
+  async startChunkedUpload(path2, totalSize, mimeType, options) {
     await this.ensureMigrated();
     try {
       const { CHUNK_SIZE: CHUNK_SIZE2, normalizePath: normalizePath2, basename: basename2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const normalizedPath = normalizePath2(path);
+      const normalizedPath = normalizePath2(path2);
       const name = basename2(normalizedPath);
       const now = Date.now();
       const expectedChunks = Math.ceil(totalSize / CHUNK_SIZE2);
@@ -28905,11 +28888,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    * @param chunkIndex - 0-based chunk index
    * @param data - Base64 encoded chunk data
    */
-  async writeFileChunk(path, chunkIndex, data) {
+  async writeFileChunk(path2, chunkIndex, data) {
     await this.ensureMigrated();
     try {
       const { normalizePath: normalizePath2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const normalizedPath = normalizePath2(path);
+      const normalizedPath = normalizePath2(path2);
       const binaryString = atob(data);
       const dataBuffer = new Uint8Array(binaryString.length);
       for (let i = 0; i < binaryString.length; i++) {
@@ -28931,12 +28914,12 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    * Complete a chunked file upload.
    * Validates all chunks are present and sets chunk_count.
    */
-  async completeChunkedUpload(path, expectedChunks, options) {
+  async completeChunkedUpload(path2, expectedChunks, options) {
     await this.ensureMigrated();
     try {
       const { normalizePath: normalizePath2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const fs = this.getFileStorage();
-      const normalizedPath = normalizePath2(path);
+      const fs2 = this.getFileStorage();
+      const normalizedPath = normalizePath2(path2);
       const countResult = await this.ctx.storage.sql.exec(
         `SELECT COUNT(*) as count FROM file_chunks WHERE file_path = ?`,
         normalizedPath
@@ -28962,7 +28945,7 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
         thumbnailBuffer || null,
         normalizedPath
       );
-      const file = await fs.stat(normalizedPath);
+      const file = await fs2.stat(normalizedPath);
       if (file) {
         this.broadcastEvent("file_created", { path: normalizedPath, file });
       }
@@ -28976,11 +28959,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    * Read a single chunk of a file.
    * Use for streaming large files to client.
    */
-  async readFileChunk(path, chunkIndex) {
+  async readFileChunk(path2, chunkIndex) {
     await this.ensureMigrated();
     try {
       const { normalizePath: normalizePath2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const normalizedPath = normalizePath2(path);
+      const normalizedPath = normalizePath2(path2);
       const cursor = await this.ctx.storage.sql.exec(
         `SELECT data FROM file_chunks WHERE file_path = ? AND chunk_index = ?`,
         normalizedPath,
@@ -29005,11 +28988,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Get file info including chunking metadata.
    */
-  async getFileInfo(path) {
+  async getFileInfo(path2) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const file = await fs.stat(path);
+      const fs2 = this.getFileStorage();
+      const file = await fs2.stat(path2);
       if (!file) {
         return { success: false, error: "File not found" };
       }
@@ -29227,16 +29210,16 @@ function parseUserRouteKey(key) {
   }
   return { key, method, segments, dynamism };
 }
-function matchSegments(route, path) {
+function matchSegments(route, path2) {
   const params = {};
   for (let i = 0; i < route.length; i++) {
     const seg = route[i];
     if (seg === "[*]") {
       if (i !== route.length - 1) return null;
-      params["*"] = path.slice(i).join("/");
+      params["*"] = path2.slice(i).join("/");
       return params;
     }
-    const value = path[i];
+    const value = path2[i];
     if (value === void 0) return null;
     if (seg.startsWith("[") && seg.endsWith("]")) {
       params[seg.slice(1, -1)] = value;
@@ -29244,16 +29227,16 @@ function matchSegments(route, path) {
       return null;
     }
   }
-  return path.length === route.length ? params : null;
+  return path2.length === route.length ? params : null;
 }
 function matchUserRoute(keys, method, endpointPath) {
-  const path = endpointPath.split("/").filter((s) => s.length > 0);
+  const path2 = endpointPath.split("/").filter((s) => s.length > 0);
   const wanted = method.toUpperCase();
   let best = null;
   for (const key of keys) {
     const route = parseUserRouteKey(key);
     if (route.method !== wanted) continue;
-    const params = matchSegments(route.segments, path);
+    const params = matchSegments(route.segments, path2);
     if (!params) continue;
     if (!best || route.dynamism < best.route.dynamism) {
       best = { route, params };