sandlot 0.1.2 → 0.1.4

package/dist/internal.js

@@ -1,3 +1,11 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/loader.ts
 class ModuleLoadError extends Error {
   constructor(message, cause) {
@@ -514,9 +522,6 @@ async function listPackages(fs) {
 // src/ts-libs.ts
 var TS_VERSION = "5.9.3";
 var CDN_BASE = `https://cdn.jsdelivr.net/npm/typescript@${TS_VERSION}/lib`;
-var DB_NAME = "ts-lib-cache";
-var DB_VERSION = 1;
-var STORE_NAME = "libs";
 function getDefaultBrowserLibs() {
   return ["es2020", "dom", "dom.iterable"];
 }
@@ -581,110 +586,54 @@ async function fetchAllLibs(libs) {
   }
   return result;
 }
-async function openDatabase() {
-  return new Promise((resolve, reject) => {
-    const request = indexedDB.open(DB_NAME, DB_VERSION);
-    request.onerror = () => reject(request.error);
-    request.onsuccess = () => resolve(request.result);
-    request.onupgradeneeded = (event) => {
-      const db = event.target.result;
-      if (!db.objectStoreNames.contains(STORE_NAME)) {
-        db.createObjectStore(STORE_NAME);
-      }
-    };
-  });
-}
-function promisifyRequest(request) {
-  return new Promise((resolve, reject) => {
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error);
-  });
-}
-function getCacheKey() {
-  return `libs-${TS_VERSION}`;
-}
+var memoryCache = null;
 
 class LibCache {
-  db;
-  constructor(db) {
-    this.db = db;
-  }
-  static async create() {
-    const db = await openDatabase();
-    return new LibCache(db);
-  }
   async getOrFetch(libs) {
-    const cached = await this.get();
-    if (cached) {
-      const missing = libs.filter((lib) => !cached.has(lib));
+    if (memoryCache) {
+      const missing = libs.filter((lib) => !memoryCache.has(lib));
       if (missing.length === 0) {
-        return cached;
+        return memoryCache;
       }
       console.log(`Cache missing libs: ${missing.join(", ")}, fetching all...`);
     }
     console.log(`Fetching TypeScript libs from CDN: ${libs.join(", ")}...`);
     const fetched = await fetchAllLibs(libs);
     console.log(`Fetched ${fetched.size} lib files`);
-    await this.set(fetched);
+    memoryCache = fetched;
     return fetched;
   }
-  async get() {
-    const tx = this.db.transaction(STORE_NAME, "readonly");
-    const store = tx.objectStore(STORE_NAME);
-    const key = getCacheKey();
-    const cached = await promisifyRequest(store.get(key));
-    if (!cached) {
-      return null;
-    }
-    if (cached.version !== TS_VERSION) {
-      console.log(`Cache version mismatch: ${cached.version} vs ${TS_VERSION}`);
-      return null;
-    }
-    return new Map(Object.entries(cached.libs));
-  }
-  async set(libs) {
-    const tx = this.db.transaction(STORE_NAME, "readwrite");
-    const store = tx.objectStore(STORE_NAME);
-    const key = getCacheKey();
-    const cached = {
-      version: TS_VERSION,
-      timestamp: Date.now(),
-      libs: Object.fromEntries(libs)
-    };
-    await promisifyRequest(store.put(cached, key));
+  get() {
+    return memoryCache;
   }
-  async clear() {
-    const tx = this.db.transaction(STORE_NAME, "readwrite");
-    const store = tx.objectStore(STORE_NAME);
-    await promisifyRequest(store.clear());
+  set(libs) {
+    memoryCache = libs;
   }
-  close() {
-    this.db.close();
+  clear() {
+    memoryCache = null;
   }
 }
 async function fetchAndCacheLibs(libs = getDefaultBrowserLibs()) {
-  const cache = await LibCache.create();
-  try {
-    return await cache.getOrFetch(libs);
-  } finally {
-    cache.close();
-  }
+  const cache = new LibCache;
+  return cache.getOrFetch(libs);
 }
 // src/shared-modules.ts
 var GLOBAL_KEY = "__sandlot_shared_modules__";
 
 class SharedModuleRegistry {
   modules = new Map;
+  exportNames = new Map;
   constructor() {
     globalThis[GLOBAL_KEY] = this;
   }
   register(moduleId, module) {
     this.modules.set(moduleId, module);
+    this.exportNames.set(moduleId, introspectExports(module));
     return this;
   }
   registerAll(modules) {
     for (const [id, mod] of Object.entries(modules)) {
-      this.modules.set(id, mod);
+      this.register(id, mod);
     }
     return this;
   }
@@ -705,13 +654,44 @@ class SharedModuleRegistry {
   list() {
     return [...this.modules.keys()];
   }
+  getExportNames(moduleId) {
+    return this.exportNames.get(moduleId) ?? [];
+  }
   clear() {
     this.modules.clear();
+    this.exportNames.clear();
   }
   get size() {
     return this.modules.size;
   }
 }
+function introspectExports(module) {
+  if (module === null || module === undefined) {
+    return [];
+  }
+  if (typeof module !== "object" && typeof module !== "function") {
+    return [];
+  }
+  const exports = [];
+  for (const key of Object.keys(module)) {
+    if (isValidIdentifier(key)) {
+      exports.push(key);
+    }
+  }
+  return exports;
+}
+function isValidIdentifier(name) {
+  if (name.length === 0)
+    return false;
+  if (!/^[a-zA-Z_$]/.test(name))
+    return false;
+  if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name))
+    return false;
+  const reserved = ["default", "class", "function", "var", "let", "const", "import", "export"];
+  if (reserved.includes(name))
+    return false;
+  return true;
+}
 var defaultRegistry = null;
 function getSharedModuleRegistry() {
   if (!defaultRegistry) {
@@ -731,6 +711,9 @@ function unregisterSharedModule(moduleId) {
 function clearSharedModules() {
   getSharedModuleRegistry().clear();
 }
+function getSharedModuleExports(moduleId) {
+  return getSharedModuleRegistry().getExportNames(moduleId);
+}
 function getSharedModuleRuntimeCode(moduleId) {
   return `
 (function() {
@@ -745,7 +728,21 @@ function getSharedModuleRuntimeCode(moduleId) {
 })()
 `.trim();
 }
-// src/commands.ts
+// src/commands/types.ts
+function formatEsbuildMessages(messages) {
+  if (messages.length === 0)
+    return "";
+  return messages.map((msg) => {
+    if (msg.location) {
+      const { file, line, column } = msg.location;
+      const loc = file ? `${file}${line ? `:${line}` : ""}${column ? `:${column}` : ""}` : "";
+      return loc ? `${loc}: ${msg.text}` : msg.text;
+    }
+    return msg.text;
+  }).join(`
+`);
+}
+// src/commands/compile.ts
 import { defineCommand } from "just-bash/browser";
 
 // src/typechecker.ts
@@ -1082,15 +1079,32 @@ function formatDiagnosticsForAgent(diagnostics) {
 
 // src/bundler.ts
 var esbuild = null;
+function isServerEnvironment() {
+  if (typeof globalThis !== "undefined" && "Bun" in globalThis) {
+    return true;
+  }
+  if (typeof globalThis !== "undefined" && "Deno" in globalThis) {
+    return true;
+  }
+  if (typeof process !== "undefined" && process.versions?.node) {
+    return true;
+  }
+  return false;
+}
 async function getEsbuild() {
   if (esbuild)
     return esbuild;
-  const cdnUrl = `https://esm.sh/esbuild-wasm@${ESBUILD_VERSION}`;
-  const mod = await import(cdnUrl);
-  esbuild = mod.default ?? mod;
-  if (typeof esbuild?.initialize !== "function") {
-    console.error("esbuild-wasm module structure:", mod);
-    throw new Error("Failed to load esbuild-wasm: initialize function not found");
+  if (isServerEnvironment()) {
+    const mod = await import("esbuild");
+    esbuild = mod.default ?? mod;
+  } else {
+    const cdnUrl = `https://esm.sh/esbuild-wasm@${ESBUILD_VERSION}`;
+    const mod = await import(cdnUrl);
+    esbuild = mod.default ?? mod;
+    if (typeof esbuild?.initialize !== "function") {
+      console.error("esbuild-wasm module structure:", mod);
+      throw new Error("Failed to load esbuild-wasm: initialize function not found");
+    }
   }
   return esbuild;
 }
@@ -1118,12 +1132,14 @@ async function initBundler() {
     await initPromise;
     return;
   }
-  checkCrossOriginIsolation();
   initPromise = (async () => {
     const es = await getEsbuild();
-    await es.initialize({
-      wasmURL: getWasmUrl()
-    });
+    if (!isServerEnvironment() && typeof es.initialize === "function") {
+      checkCrossOriginIsolation();
+      await es.initialize({
+        wasmURL: getWasmUrl()
+      });
+    }
   })();
   await initPromise;
   initialized = true;
@@ -1262,55 +1278,12 @@ ${generateNamedExports(args.path)}
   };
 }
 function generateNamedExports(moduleId) {
-  const knownExports = {
-    react: [
-      "useState",
-      "useEffect",
-      "useContext",
-      "useReducer",
-      "useCallback",
-      "useMemo",
-      "useRef",
-      "useImperativeHandle",
-      "useLayoutEffect",
-      "useDebugValue",
-      "useDeferredValue",
-      "useTransition",
-      "useId",
-      "useSyncExternalStore",
-      "useInsertionEffect",
-      "useOptimistic",
-      "useActionState",
-      "createElement",
-      "cloneElement",
-      "createContext",
-      "forwardRef",
-      "lazy",
-      "memo",
-      "startTransition",
-      "Children",
-      "Component",
-      "PureComponent",
-      "Fragment",
-      "Profiler",
-      "StrictMode",
-      "Suspense",
-      "version",
-      "isValidElement"
-    ],
-    "react-dom": ["createPortal", "flushSync", "version"],
-    "react-dom/client": ["createRoot", "hydrateRoot"],
-    "react-dom/server": ["renderToString", "renderToStaticMarkup", "renderToPipeableStream"]
-  };
-  const exports = knownExports[moduleId];
-  if (!exports) {
-    return `
-// Dynamic re-export for unknown module
-export const __moduleProxy__ = __sandlot_mod__;
-`;
-  }
-  return exports.map((name) => `export const ${name} = __sandlot_mod__.${name};`).join(`
+  const exports = getSharedModuleExports(moduleId);
+  if (exports.length > 0) {
+    return exports.map((name) => `export const ${name} = __sandlot_mod__.${name};`).join(`
 `);
+  }
+  return `// No exports discovered for "${moduleId}" - use default import or call registerSharedModules() first`;
 }
 async function bundle(options) {
   await initBundler();
@@ -1353,7 +1326,8 @@ async function bundle(options) {
     globalName,
     target,
     external,
-    plugins: [plugin]
+    plugins: [plugin],
+    jsx: "automatic"
   });
   const code = result.outputFiles?.[0]?.text ?? "";
   return {
@@ -1376,20 +1350,7 @@ async function bundleAndImport(options) {
   }
 }
 
-// src/commands.ts
-function formatEsbuildMessages(messages) {
-  if (messages.length === 0)
-    return "";
-  return messages.map((msg) => {
-    if (msg.location) {
-      const { file, line, column } = msg.location;
-      const loc = file ? `${file}${line ? `:${line}` : ""}${column ? `:${column}` : ""}` : "";
-      return loc ? `${loc}: ${msg.text}` : msg.text;
-    }
-    return msg.text;
-  }).join(`
-`);
-}
+// src/commands/compile.ts
 function createTscCommand(deps) {
   const { fs, libFiles, tsconfigPath } = deps;
   return defineCommand("tsc", async (args, _ctx) => {
@@ -1454,7 +1415,7 @@ ${formatDiagnosticsForAgent(result.diagnostics.filter((d) => d.category === "war
   });
 }
 function createBuildCommand(deps) {
-  const { fs, libFiles, tsconfigPath, onBuild, sharedModules } = deps;
+  const { fs, libFiles, tsconfigPath, onBuild, getValidation, sharedModules } = deps;
   return defineCommand("build", async (args, _ctx) => {
     let entryPoint = null;
     let skipTypecheck = false;
@@ -1526,8 +1487,39 @@ ${formatted}
         minify,
         sharedModules
       });
+      let loadedModule;
+      try {
+        loadedModule = await loadModule(bundleResult);
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        return {
+          stdout: "",
+          stderr: `Build failed: Module failed to load.
+
+${errorMessage}
+`,
+          exitCode: 1
+        };
+      }
+      const validateFn = getValidation?.();
+      let validatedModule = loadedModule;
+      if (validateFn) {
+        try {
+          validatedModule = validateFn(loadedModule);
+        } catch (err) {
+          const errorMessage = err instanceof Error ? err.message : String(err);
+          return {
+            stdout: "",
+            stderr: `Build failed: Validation error.
+
+${errorMessage}
+`,
+            exitCode: 1
+          };
+        }
+      }
       if (onBuild) {
-        await onBuild(bundleResult);
+        await onBuild({ bundle: bundleResult, module: validatedModule });
       }
       let output = `Build successful!
 `;
@@ -1543,6 +1535,15 @@ ${formatted}
       }
       output += `Bundled: ${bundleResult.includedFiles.length} file(s)
 `;
+      const exportNames = Object.keys(loadedModule).filter((k) => !k.startsWith("__"));
+      if (exportNames.length > 0) {
+        output += `Exports: ${exportNames.join(", ")}
+`;
+      }
+      if (validateFn) {
+        output += `Validation: passed
+`;
+      }
       if (bundleResult.warnings.length > 0) {
         output += `
 Build warnings:
@@ -1574,9 +1575,11 @@ ${formatDiagnosticsForAgent(warnings)}
     }
   });
 }
+// src/commands/packages.ts
+import { defineCommand as defineCommand2 } from "just-bash/browser";
 function createInstallCommand(deps) {
   const { fs, typesCache } = deps;
-  return defineCommand("install", async (args, _ctx) => {
+  return defineCommand2("install", async (args, _ctx) => {
     if (args.length === 0) {
       return {
         stdout: "",
@@ -1630,7 +1633,7 @@ Examples:
 }
 function createUninstallCommand(deps) {
   const { fs } = deps;
-  return defineCommand("uninstall", async (args, _ctx) => {
+  return defineCommand2("uninstall", async (args, _ctx) => {
     if (args.length === 0) {
       return {
         stdout: "",
@@ -1675,7 +1678,7 @@ function createUninstallCommand(deps) {
 }
 function createListCommand(deps) {
   const { fs } = deps;
-  return defineCommand("list", async (_args, _ctx) => {
+  return defineCommand2("list", async (_args, _ctx) => {
     try {
       const packages = await listPackages(fs);
       if (packages.length === 0) {
@@ -1705,9 +1708,11 @@ function createListCommand(deps) {
     }
   });
 }
+// src/commands/run.ts
+import { defineCommand as defineCommand3 } from "just-bash/browser";
 function createRunCommand(deps) {
   const { fs, libFiles, tsconfigPath, runOptions = {}, sharedModules } = deps;
-  return defineCommand("run", async (args, _ctx) => {
+  return defineCommand3("run", async (args, _ctx) => {
     let entryPoint = null;
     let skipTypecheck = runOptions.skipTypecheck ?? false;
     let timeout = runOptions.timeout ?? 30000;
@@ -1884,6 +1889,7 @@ ${err.stack}` : "";
     }
   });
 }
+// src/commands/index.ts
 function createDefaultCommands(deps) {
   return [
     createTscCommand(deps),
@@ -1897,9 +1903,7 @@ function createDefaultCommands(deps) {
 // src/build-emitter.ts
 class BuildEmitter {
   listeners = new Set;
-  lastResult = null;
   emit = async (result) => {
-    this.lastResult = result;
     const promises = [];
     for (const listener of this.listeners) {
       const ret = listener(result);
@@ -1915,20 +1919,6 @@ class BuildEmitter {
       this.listeners.delete(callback);
     };
   }
-  waitFor() {
-    if (this.lastResult) {
-      const result = this.lastResult;
-      this.lastResult = null;
-      return Promise.resolve(result);
-    }
-    return new Promise((resolve) => {
-      const unsub = this.on((result) => {
-        unsub();
-        this.lastResult = null;
-        resolve(result);
-      });
-    });
-  }
 }
 export {
   revokeModuleUrl,