veryfront 0.0.34 → 0.0.36

package/dist/ai/index.js

@@ -1672,60 +1672,18 @@ var SERVER_ACTION_DEFAULT_TTL_SEC = MINUTES_PER_HOUR * SECONDS_PER_MINUTE;
 var ONE_DAY_MS = HOURS_PER_DAY * MINUTES_PER_HOUR * SECONDS_PER_MINUTE * MS_PER_SECOND;
 var LRU_DEFAULT_MAX_SIZE_BYTES = 50 * 1024 * 1024;
 
-// src/core/utils/constants/cdn.ts
-var ESM_CDN_BASE = "https://esm.sh";
-var REACT_VERSION_18_3 = "18.3.1";
-var REACT_DEFAULT_VERSION = REACT_VERSION_18_3;
-function getReactCDNUrl(version = REACT_DEFAULT_VERSION) {
-  return `${ESM_CDN_BASE}/react@${version}`;
-}
-function getReactDOMCDNUrl(version = REACT_DEFAULT_VERSION) {
-  return `${ESM_CDN_BASE}/react-dom@${version}`;
-}
-function getReactDOMClientCDNUrl(version = REACT_DEFAULT_VERSION) {
-  return `${ESM_CDN_BASE}/react-dom@${version}/client`;
-}
-function getReactDOMServerCDNUrl(version = REACT_DEFAULT_VERSION) {
-  return `${ESM_CDN_BASE}/react-dom@${version}/server`;
-}
-function getReactJSXRuntimeCDNUrl(version = REACT_DEFAULT_VERSION) {
-  return `${ESM_CDN_BASE}/react@${version}/jsx-runtime`;
-}
-function getReactJSXDevRuntimeCDNUrl(version = REACT_DEFAULT_VERSION) {
-  return `${ESM_CDN_BASE}/react@${version}/jsx-dev-runtime`;
-}
-function getReactImportMap(version = REACT_DEFAULT_VERSION) {
-  return {
-    react: getReactCDNUrl(version),
-    "react-dom": getReactDOMCDNUrl(version),
-    "react-dom/client": getReactDOMClientCDNUrl(version),
-    "react-dom/server": getReactDOMServerCDNUrl(version),
-    "react/jsx-runtime": getReactJSXRuntimeCDNUrl(version),
-    "react/jsx-dev-runtime": getReactJSXDevRuntimeCDNUrl(version)
-  };
-}
-
-// src/core/utils/constants/http.ts
-var KB_IN_BYTES = 1024;
-var PREFETCH_MAX_SIZE_BYTES = 200 * KB_IN_BYTES;
-
-// src/core/utils/constants/hmr.ts
-var HMR_MAX_MESSAGE_SIZE_BYTES = 1024 * KB_IN_BYTES;
-
-// src/core/utils/constants/network.ts
-var BYTES_PER_MB = 1024 * 1024;
-
 // deno.json
 var deno_default = {
   name: "veryfront",
-  version: "0.0.34",
+  version: "0.0.36",
   exclude: [
     "npm/",
     "dist/",
     "coverage/",
     "scripts/",
     "examples/",
-    "tests/"
+    "tests/",
+    "src/cli/templates/files/"
   ],
   exports: {
     ".": "./src/index.ts",
@@ -1735,6 +1693,7 @@ var deno_default = {
     "./components": "./src/react/components/index.ts",
     "./data": "./src/data/index.ts",
     "./config": "./src/core/config/index.ts",
+    "./platform": "./src/platform/index.ts",
     "./ai": "./src/ai/index.ts",
     "./ai/client": "./src/ai/client.ts",
     "./ai/react": "./src/ai/react/index.ts",
@@ -1914,6 +1873,140 @@ var deno_default = {
 // src/core/utils/version.ts
 var VERSION = getEnv("VERYFRONT_VERSION") || (typeof deno_default.version === "string" ? deno_default.version : "0.0.0");
 
+// src/core/utils/constants/cdn.ts
+var ESM_CDN_BASE = "https://esm.sh";
+var REACT_VERSION_18_3 = "18.3.1";
+var REACT_DEFAULT_VERSION = REACT_VERSION_18_3;
+function getReactCDNUrl(version = REACT_DEFAULT_VERSION) {
+  return `${ESM_CDN_BASE}/react@${version}`;
+}
+function getReactDOMCDNUrl(version = REACT_DEFAULT_VERSION) {
+  return `${ESM_CDN_BASE}/react-dom@${version}`;
+}
+function getReactDOMClientCDNUrl(version = REACT_DEFAULT_VERSION) {
+  return `${ESM_CDN_BASE}/react-dom@${version}/client`;
+}
+function getReactDOMServerCDNUrl(version = REACT_DEFAULT_VERSION) {
+  return `${ESM_CDN_BASE}/react-dom@${version}/server`;
+}
+function getReactJSXRuntimeCDNUrl(version = REACT_DEFAULT_VERSION) {
+  return `${ESM_CDN_BASE}/react@${version}/jsx-runtime`;
+}
+function getReactJSXDevRuntimeCDNUrl(version = REACT_DEFAULT_VERSION) {
+  return `${ESM_CDN_BASE}/react@${version}/jsx-dev-runtime`;
+}
+function getReactImportMap(version = REACT_DEFAULT_VERSION) {
+  return {
+    react: getReactCDNUrl(version),
+    "react-dom": getReactDOMCDNUrl(version),
+    "react-dom/client": getReactDOMClientCDNUrl(version),
+    "react-dom/server": getReactDOMServerCDNUrl(version),
+    "react/jsx-runtime": getReactJSXRuntimeCDNUrl(version),
+    "react/jsx-dev-runtime": getReactJSXDevRuntimeCDNUrl(version)
+  };
+}
+
+// src/core/utils/constants/http.ts
+var KB_IN_BYTES = 1024;
+var PREFETCH_MAX_SIZE_BYTES = 200 * KB_IN_BYTES;
+
+// src/core/utils/constants/hmr.ts
+var HMR_MAX_MESSAGE_SIZE_BYTES = 1024 * KB_IN_BYTES;
+
+// src/core/utils/constants/network.ts
+var BYTES_PER_MB = 1024 * 1024;
+
+// src/core/utils/constants/server.ts
+var INTERNAL_PREFIX = "/_veryfront";
+var INTERNAL_PATH_PREFIXES = {
+  /** React Server Components endpoints */
+  RSC: `${INTERNAL_PREFIX}/rsc/`,
+  /** File system access endpoints (base64 encoded paths) */
+  FS: `${INTERNAL_PREFIX}/fs/`,
+  /** Virtual module system */
+  MODULES: `${INTERNAL_PREFIX}/modules/`,
+  /** Generated page modules */
+  PAGES: `${INTERNAL_PREFIX}/pages/`,
+  /** Data JSON endpoints */
+  DATA: `${INTERNAL_PREFIX}/data/`,
+  /** Library modules (AI SDK, etc.) */
+  LIB: `${INTERNAL_PREFIX}/lib/`,
+  /** Chunk assets */
+  CHUNKS: `${INTERNAL_PREFIX}/chunks/`,
+  /** Client component modules */
+  CLIENT: `${INTERNAL_PREFIX}/client/`
+};
+var INTERNAL_ENDPOINTS = {
+  // Development endpoints
+  HMR_RUNTIME: `${INTERNAL_PREFIX}/hmr-runtime.js`,
+  HMR: `${INTERNAL_PREFIX}/hmr.js`,
+  HYDRATE: `${INTERNAL_PREFIX}/hydrate.js`,
+  ERROR_OVERLAY: `${INTERNAL_PREFIX}/error-overlay.js`,
+  DEV_LOADER: `${INTERNAL_PREFIX}/dev-loader.js`,
+  CLIENT_LOG: `${INTERNAL_PREFIX}/log`,
+  // Production endpoints
+  CLIENT_JS: `${INTERNAL_PREFIX}/client.js`,
+  ROUTER_JS: `${INTERNAL_PREFIX}/router.js`,
+  PREFETCH_JS: `${INTERNAL_PREFIX}/prefetch.js`,
+  MANIFEST_JSON: `${INTERNAL_PREFIX}/manifest.json`,
+  APP_JS: `${INTERNAL_PREFIX}/app.js`,
+  // RSC endpoints
+  RSC_CLIENT: `${INTERNAL_PREFIX}/rsc/client.js`,
+  RSC_MANIFEST: `${INTERNAL_PREFIX}/rsc/manifest`,
+  RSC_STREAM: `${INTERNAL_PREFIX}/rsc/stream`,
+  RSC_PAYLOAD: `${INTERNAL_PREFIX}/rsc/payload`,
+  RSC_RENDER: `${INTERNAL_PREFIX}/rsc/render`,
+  RSC_PAGE: `${INTERNAL_PREFIX}/rsc/page`,
+  RSC_MODULE: `${INTERNAL_PREFIX}/rsc/module`,
+  RSC_DOM: `${INTERNAL_PREFIX}/rsc/dom.js`,
+  RSC_HYDRATOR: `${INTERNAL_PREFIX}/rsc/hydrator.js`,
+  RSC_HYDRATE_CLIENT: `${INTERNAL_PREFIX}/rsc/hydrate-client.js`,
+  // Library module endpoints
+  LIB_AI_REACT: `${INTERNAL_PREFIX}/lib/ai/react.js`,
+  LIB_AI_COMPONENTS: `${INTERNAL_PREFIX}/lib/ai/components.js`,
+  LIB_AI_PRIMITIVES: `${INTERNAL_PREFIX}/lib/ai/primitives.js`
+};
+var BUILD_DIRS = {
+  /** Main build output directory */
+  ROOT: "_veryfront",
+  /** Chunks directory */
+  CHUNKS: "_veryfront/chunks",
+  /** Data directory */
+  DATA: "_veryfront/data",
+  /** Assets directory */
+  ASSETS: "_veryfront/assets"
+};
+var PROJECT_DIRS = {
+  /** Base veryfront internal directory */
+  ROOT: ".veryfront",
+  /** Cache directory for build artifacts, transforms, etc. */
+  CACHE: ".veryfront/cache",
+  /** KV store directory */
+  KV: ".veryfront/kv",
+  /** Log files directory */
+  LOGS: ".veryfront/logs",
+  /** Temporary files directory */
+  TMP: ".veryfront/tmp"
+};
+var DEFAULT_CACHE_DIR = PROJECT_DIRS.CACHE;
+var DEV_SERVER_ENDPOINTS = {
+  HMR_RUNTIME: INTERNAL_ENDPOINTS.HMR_RUNTIME,
+  ERROR_OVERLAY: INTERNAL_ENDPOINTS.ERROR_OVERLAY
+};
+
+// src/core/utils/paths.ts
+var VERYFRONT_PATHS = {
+  INTERNAL_PREFIX,
+  BUILD_DIR: BUILD_DIRS.ROOT,
+  CHUNKS_DIR: BUILD_DIRS.CHUNKS,
+  DATA_DIR: BUILD_DIRS.DATA,
+  ASSETS_DIR: BUILD_DIRS.ASSETS,
+  HMR_RUNTIME: INTERNAL_ENDPOINTS.HMR_RUNTIME,
+  CLIENT_JS: INTERNAL_ENDPOINTS.CLIENT_JS,
+  ROUTER_JS: INTERNAL_ENDPOINTS.ROUTER_JS,
+  ERROR_OVERLAY: INTERNAL_ENDPOINTS.ERROR_OVERLAY
+};
+
 // src/core/utils/bundle-manifest.ts
 var InMemoryBundleManifestStore = class {
   constructor() {
@@ -3638,7 +3731,7 @@ var DEFAULT_CONFIG2 = {
     }
   },
   cache: {
-    dir: ".veryfront/cache",
+    dir: DEFAULT_CACHE_DIR,
     render: {
       type: "memory",
       ttl: void 0,
@@ -3957,7 +4050,362 @@ function createMockAdapter() {
   };
 }
 
+// src/platform/compat/fs.ts
+var NodeFileSystem = class {
+  constructor() {
+    this.fs = null;
+    this.os = null;
+    this.path = null;
+    this.initialized = false;
+  }
+  async ensureInitialized() {
+    if (this.initialized)
+      return;
+    if (!isNode) {
+      throw toError(createError({
+        type: "not_supported",
+        message: "Node.js fs modules not available",
+        feature: "Node.js"
+      }));
+    }
+    const [fsModule, osModule, pathModule] = await Promise.all([
+      import("node:fs/promises"),
+      import("node:os"),
+      import("node:path")
+    ]);
+    this.fs = fsModule;
+    this.os = osModule;
+    this.path = pathModule;
+    this.initialized = true;
+  }
+  async readTextFile(path) {
+    await this.ensureInitialized();
+    return await this.fs.readFile(path, { encoding: "utf8" });
+  }
+  async readFile(path) {
+    await this.ensureInitialized();
+    return await this.fs.readFile(path);
+  }
+  async writeTextFile(path, data) {
+    await this.ensureInitialized();
+    await this.fs.writeFile(path, data, { encoding: "utf8" });
+  }
+  async writeFile(path, data) {
+    await this.ensureInitialized();
+    await this.fs.writeFile(path, data);
+  }
+  async exists(path) {
+    await this.ensureInitialized();
+    try {
+      await this.fs.access(path);
+      return true;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async stat(path) {
+    await this.ensureInitialized();
+    const stat = await this.fs.stat(path);
+    return {
+      isFile: stat.isFile(),
+      isDirectory: stat.isDirectory(),
+      isSymlink: stat.isSymbolicLink(),
+      size: stat.size,
+      mtime: stat.mtime
+    };
+  }
+  async mkdir(path, options) {
+    await this.ensureInitialized();
+    await this.fs.mkdir(path, { recursive: options?.recursive ?? false });
+  }
+  async *readDir(path) {
+    await this.ensureInitialized();
+    const entries = await this.fs.readdir(path, { withFileTypes: true });
+    for (const entry of entries) {
+      yield {
+        name: entry.name,
+        isFile: entry.isFile(),
+        isDirectory: entry.isDirectory()
+      };
+    }
+  }
+  async remove(path, options) {
+    await this.ensureInitialized();
+    await this.fs.rm(path, {
+      recursive: options?.recursive ?? false,
+      force: options?.recursive ?? false
+    });
+  }
+  async makeTempDir(options) {
+    await this.ensureInitialized();
+    const tempDir = this.path.join(
+      this.os.tmpdir(),
+      `${options?.prefix ?? "tmp-"}${Math.random().toString(36).substring(2, 8)}`
+    );
+    await this.fs.mkdir(tempDir, { recursive: true });
+    return tempDir;
+  }
+};
+var DenoFileSystem = class {
+  async readTextFile(path) {
+    return await Deno.readTextFile(path);
+  }
+  async readFile(path) {
+    return await Deno.readFile(path);
+  }
+  async writeTextFile(path, data) {
+    await Deno.writeTextFile(path, data);
+  }
+  async writeFile(path, data) {
+    await Deno.writeFile(path, data);
+  }
+  async exists(path) {
+    try {
+      await Deno.stat(path);
+      return true;
+    } catch (error) {
+      if (error instanceof Deno.errors.NotFound) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async stat(path) {
+    const stat = await Deno.stat(path);
+    return {
+      isFile: stat.isFile,
+      isDirectory: stat.isDirectory,
+      isSymlink: stat.isSymlink,
+      size: stat.size,
+      mtime: stat.mtime
+    };
+  }
+  async mkdir(path, options) {
+    await Deno.mkdir(path, { recursive: options?.recursive ?? false });
+  }
+  async *readDir(path) {
+    for await (const entry of Deno.readDir(path)) {
+      yield {
+        name: entry.name,
+        isFile: entry.isFile,
+        isDirectory: entry.isDirectory
+      };
+    }
+  }
+  async remove(path, options) {
+    await Deno.remove(path, { recursive: options?.recursive ?? false });
+  }
+  async makeTempDir(options) {
+    return await Deno.makeTempDir({ prefix: options?.prefix });
+  }
+};
+function createFileSystem() {
+  if (isDeno) {
+    return new DenoFileSystem();
+  } else {
+    return new NodeFileSystem();
+  }
+}
+
+// src/platform/compat/path-helper.ts
+import nodePath from "node:path";
+var pathMod = null;
+if (typeof Deno === "undefined") {
+  pathMod = nodePath;
+} else {
+  import("node:path").then((mod) => {
+    pathMod = mod;
+  });
+}
+function getPathMod() {
+  if (pathMod)
+    return pathMod;
+  return nodePath;
+}
+var dirname = (path) => getPathMod().dirname(path);
+var join2 = (...paths) => getPathMod().join(...paths);
+var sep = nodePath.sep;
+
 // src/ai/utils/discovery.ts
+var transpileCache = /* @__PURE__ */ new Map();
+async function importModule(file, context) {
+  const cacheKey = file;
+  if (transpileCache.has(cacheKey)) {
+    return transpileCache.get(cacheKey);
+  }
+  const fs2 = createFileSystem();
+  const filePath = file.replace("file://", "");
+  let source;
+  try {
+    source = await fs2.readTextFile(filePath);
+  } catch (error) {
+    throw new Error(`Failed to read file ${filePath}: ${error}`);
+  }
+  const isTsx = filePath.endsWith(".tsx");
+  const isJsx = filePath.endsWith(".jsx");
+  const loader = isTsx ? "tsx" : isJsx ? "jsx" : filePath.endsWith(".ts") ? "ts" : "js";
+  const { build } = await import("esbuild");
+  const result = await build({
+    bundle: true,
+    write: false,
+    format: "esm",
+    platform: "neutral",
+    target: "es2022",
+    jsx: "automatic",
+    jsxImportSource: "react",
+    resolveExtensions: [".ts", ".tsx", ".js", ".jsx", ".mjs"],
+    external: [
+      "ai",
+      "ai/*",
+      "@ai-sdk/*",
+      "zod",
+      "node:*",
+      "veryfront",
+      "veryfront/*",
+      "@opentelemetry/*",
+      "path"
+    ],
+    stdin: {
+      contents: source,
+      loader,
+      resolveDir: dirname(filePath),
+      sourcefile: filePath
+    }
+  });
+  if (result.errors && result.errors.length > 0) {
+    const first = result.errors[0]?.text || "unknown error";
+    throw new Error(`Failed to transpile ${filePath}: ${first}`);
+  }
+  const js = result.outputFiles?.[0]?.text ?? "export {}";
+  const tempDir = await fs2.makeTempDir({ prefix: "vf-discovery-" });
+  const tempFile = join2(tempDir, "module.mjs");
+  let transformedCode;
+  if (isDeno) {
+    transformedCode = rewriteForDeno(js);
+  } else {
+    transformedCode = await rewriteDiscoveryImports(js, context.baseDir || ".", fs2);
+  }
+  await fs2.writeTextFile(tempFile, transformedCode);
+  try {
+    const module = await import(`file://${tempFile}?v=${Date.now()}`);
+    transpileCache.set(cacheKey, module);
+    return module;
+  } finally {
+    await fs2.remove(tempDir, { recursive: true });
+  }
+}
+function rewriteForDeno(code) {
+  let transformed = code;
+  const npmPackages = [
+    { pattern: /from\s+["']ai["']/g, replacement: 'from "npm:ai"' },
+    { pattern: /from\s+["']ai\/([^"']+)["']/g, replacement: 'from "npm:ai/$1"' },
+    { pattern: /from\s+["']@ai-sdk\/([^"']+)["']/g, replacement: 'from "npm:@ai-sdk/$1"' },
+    { pattern: /from\s+["']zod["']/g, replacement: 'from "npm:zod"' },
+    { pattern: /import\s*\(\s*["']ai["']\s*\)/g, replacement: 'import("npm:ai")' },
+    { pattern: /import\s*\(\s*["']zod["']\s*\)/g, replacement: 'import("npm:zod")' }
+  ];
+  for (const { pattern, replacement } of npmPackages) {
+    transformed = transformed.replace(pattern, replacement);
+  }
+  return transformed;
+}
+async function rewriteDiscoveryImports(code, projectDir, fs2) {
+  let transformed = code;
+  try {
+    const { pathToFileURL } = await import("node:url");
+    const resolvePackageToFileUrl = async (packageName) => {
+      const packagePath = join2(projectDir, "node_modules", packageName);
+      const packageJsonPath = join2(packagePath, "package.json");
+      try {
+        const pkgJson = JSON.parse(await fs2.readTextFile(packageJsonPath));
+        let entryPoint;
+        if (pkgJson.exports) {
+          const dotExport = pkgJson.exports["."];
+          if (typeof dotExport === "string") {
+            entryPoint = dotExport;
+          } else if (dotExport?.import) {
+            entryPoint = dotExport.import;
+          } else if (dotExport?.default) {
+            entryPoint = dotExport.default;
+          }
+        }
+        if (!entryPoint) {
+          entryPoint = pkgJson.module || pkgJson.main || "index.js";
+        }
+        if (!entryPoint) {
+          return null;
+        }
+        const resolvedPath = join2(packagePath, entryPoint);
+        return pathToFileURL(resolvedPath).href;
+      } catch {
+        return null;
+      }
+    };
+    const externalPackagesToResolve = [
+      "zod",
+      "ai",
+      "@ai-sdk/anthropic",
+      "@ai-sdk/openai",
+      "@ai-sdk/google",
+      "@ai-sdk/mistral",
+      "@ai-sdk/provider",
+      "@ai-sdk/provider-utils"
+    ];
+    for (const pkg of externalPackagesToResolve) {
+      const escapedPkg = pkg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const staticImportRegex = new RegExp(`from\\s+["']${escapedPkg}["']`, "g");
+      if (staticImportRegex.test(transformed)) {
+        const resolvedUrl = await resolvePackageToFileUrl(pkg);
+        if (resolvedUrl) {
+          transformed = transformed.replace(staticImportRegex, `from "${resolvedUrl}"`);
+        }
+      }
+      const dynamicImportRegex = new RegExp(`import\\s*\\(\\s*["']${escapedPkg}["']\\s*\\)`, "g");
+      if (dynamicImportRegex.test(transformed)) {
+        const resolvedUrl = await resolvePackageToFileUrl(pkg);
+        if (resolvedUrl) {
+          transformed = transformed.replace(dynamicImportRegex, `import("${resolvedUrl}")`);
+        }
+      }
+    }
+    const vfPackagePath = join2(projectDir, "node_modules", "veryfront");
+    const vfPackageJsonPath = join2(vfPackagePath, "package.json");
+    let exportsMap = {};
+    try {
+      const pkgJson = JSON.parse(await fs2.readTextFile(vfPackageJsonPath));
+      exportsMap = pkgJson.exports || {};
+    } catch {
+    }
+    transformed = transformed.replace(
+      /from\s+["'](veryfront\/[^"']+)["']/g,
+      (_match, fullSpecifier) => {
+        const subpath = "./" + fullSpecifier.replace("veryfront/", "");
+        const exportEntry = exportsMap[subpath];
+        if (exportEntry?.import) {
+          const resolvedPath = join2(vfPackagePath, exportEntry.import);
+          return `from "${pathToFileURL(resolvedPath).href}"`;
+        }
+        return _match;
+      }
+    );
+    transformed = transformed.replace(
+      /from\s+["']veryfront["']/g,
+      () => {
+        const exportEntry = exportsMap["."];
+        if (exportEntry?.import) {
+          const resolvedPath = join2(vfPackagePath, exportEntry.import);
+          return `from "${pathToFileURL(resolvedPath).href}"`;
+        }
+        return 'from "veryfront"';
+      }
+    );
+  } catch {
+  }
+  return transformed;
+}
 async function discoverAll(config) {
   let aiDir = config.aiDir;
   const baseDir = config.baseDir;
@@ -3972,7 +4420,8 @@ async function discoverAll(config) {
   }
   const context = {
     platform: detectPlatform(),
-    fsAdapter: config.fsAdapter
+    fsAdapter: config.fsAdapter,
+    baseDir
   };
   const result = {
     tools: /* @__PURE__ */ new Map(),
@@ -4006,7 +4455,7 @@ async function discoverTools(dir, result, context, verbose) {
   }
   for (const file of files) {
     try {
-      const module = await import(file);
+      const module = await importModule(file, context);
       const tool2 = module.default;
       if (!tool2 || typeof tool2.execute !== "function") {
         if (verbose) {
@@ -4039,7 +4488,7 @@ async function discoverAgents(dir, result, context, verbose) {
   }
   for (const file of files) {
     try {
-      const module = await import(file);
+      const module = await importModule(file, context);
       const agent2 = module.default;
       if (!agent2 || typeof agent2.generate !== "function") {
         if (verbose) {
@@ -4072,7 +4521,7 @@ async function discoverResources(dir, result, context, verbose) {
   }
   for (const file of files) {
     try {
-      const module = await import(file);
+      const module = await importModule(file, context);
       const resource2 = module.default;
       if (!resource2 || typeof resource2.load !== "function") {
         if (verbose) {
@@ -4106,7 +4555,7 @@ async function discoverPrompts(dir, result, context, verbose) {
   }
   for (const file of files) {
     try {
-      const module = await import(file);
+      const module = await importModule(file, context);
       const promptInstance = module.default;
       if (!promptInstance || typeof promptInstance.getContent !== "function") {
         if (verbose) {
@@ -4259,166 +4708,6 @@ function toAISDKTools(tools) {
   return aiTools;
 }
 
-// src/platform/compat/fs.ts
-var NodeFileSystem = class {
-  constructor() {
-    this.fs = null;
-    this.os = null;
-    this.path = null;
-    this.initialized = false;
-  }
-  async ensureInitialized() {
-    if (this.initialized)
-      return;
-    if (!isNode) {
-      throw toError(createError({
-        type: "not_supported",
-        message: "Node.js fs modules not available",
-        feature: "Node.js"
-      }));
-    }
-    const [fsModule, osModule, pathModule] = await Promise.all([
-      import("node:fs/promises"),
-      import("node:os"),
-      import("node:path")
-    ]);
-    this.fs = fsModule;
-    this.os = osModule;
-    this.path = pathModule;
-    this.initialized = true;
-  }
-  async readTextFile(path) {
-    await this.ensureInitialized();
-    return await this.fs.readFile(path, { encoding: "utf8" });
-  }
-  async readFile(path) {
-    await this.ensureInitialized();
-    return await this.fs.readFile(path);
-  }
-  async writeTextFile(path, data) {
-    await this.ensureInitialized();
-    await this.fs.writeFile(path, data, { encoding: "utf8" });
-  }
-  async writeFile(path, data) {
-    await this.ensureInitialized();
-    await this.fs.writeFile(path, data);
-  }
-  async exists(path) {
-    await this.ensureInitialized();
-    try {
-      await this.fs.access(path);
-      return true;
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return false;
-      }
-      throw error;
-    }
-  }
-  async stat(path) {
-    await this.ensureInitialized();
-    const stat = await this.fs.stat(path);
-    return {
-      isFile: stat.isFile(),
-      isDirectory: stat.isDirectory(),
-      isSymlink: stat.isSymbolicLink(),
-      size: stat.size,
-      mtime: stat.mtime
-    };
-  }
-  async mkdir(path, options) {
-    await this.ensureInitialized();
-    await this.fs.mkdir(path, { recursive: options?.recursive ?? false });
-  }
-  async *readDir(path) {
-    await this.ensureInitialized();
-    const entries = await this.fs.readdir(path, { withFileTypes: true });
-    for (const entry of entries) {
-      yield {
-        name: entry.name,
-        isFile: entry.isFile(),
-        isDirectory: entry.isDirectory()
-      };
-    }
-  }
-  async remove(path, options) {
-    await this.ensureInitialized();
-    await this.fs.rm(path, {
-      recursive: options?.recursive ?? false,
-      force: options?.recursive ?? false
-    });
-  }
-  async makeTempDir(options) {
-    await this.ensureInitialized();
-    const tempDir = this.path.join(
-      this.os.tmpdir(),
-      `${options?.prefix ?? "tmp-"}${Math.random().toString(36).substring(2, 8)}`
-    );
-    await this.fs.mkdir(tempDir, { recursive: true });
-    return tempDir;
-  }
-};
-var DenoFileSystem = class {
-  async readTextFile(path) {
-    return await Deno.readTextFile(path);
-  }
-  async readFile(path) {
-    return await Deno.readFile(path);
-  }
-  async writeTextFile(path, data) {
-    await Deno.writeTextFile(path, data);
-  }
-  async writeFile(path, data) {
-    await Deno.writeFile(path, data);
-  }
-  async exists(path) {
-    try {
-      await Deno.stat(path);
-      return true;
-    } catch (error) {
-      if (error instanceof Deno.errors.NotFound) {
-        return false;
-      }
-      throw error;
-    }
-  }
-  async stat(path) {
-    const stat = await Deno.stat(path);
-    return {
-      isFile: stat.isFile,
-      isDirectory: stat.isDirectory,
-      isSymlink: stat.isSymlink,
-      size: stat.size,
-      mtime: stat.mtime
-    };
-  }
-  async mkdir(path, options) {
-    await Deno.mkdir(path, { recursive: options?.recursive ?? false });
-  }
-  async *readDir(path) {
-    for await (const entry of Deno.readDir(path)) {
-      yield {
-        name: entry.name,
-        isFile: entry.isFile,
-        isDirectory: entry.isDirectory
-      };
-    }
-  }
-  async remove(path, options) {
-    await Deno.remove(path, { recursive: options?.recursive ?? false });
-  }
-  async makeTempDir(options) {
-    return await Deno.makeTempDir({ prefix: options?.prefix });
-  }
-};
-function createFileSystem() {
-  if (isDeno) {
-    return new DenoFileSystem();
-  } else {
-    return new NodeFileSystem();
-  }
-}
-
 // src/ai/utils/setup.ts
 var fs = createFileSystem();
 async function setupAI(options = {}) {
@@ -5820,18 +6109,6 @@ function waitForApproval(id, options = {}) {
   };
 }
 
-// src/platform/compat/path-helper.ts
-import nodePath from "node:path";
-var pathMod = null;
-if (typeof Deno === "undefined") {
-  pathMod = nodePath;
-} else {
-  import("node:path").then((mod) => {
-    pathMod = mod;
-  });
-}
-var sep = nodePath.sep;
-
 // src/ai/workflow/backends/types.ts
 function hasLockSupport(backend) {
   return typeof backend.acquireLock === "function" && typeof backend.releaseLock === "function";