sandlot 0.1.4 → 0.2.1

package/dist/internal.js

@@ -1,1942 +0,0 @@
-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) {
-    super(message, { cause });
-    this.name = "ModuleLoadError";
-  }
-}
-
-class ExportNotFoundError extends Error {
-  exportName;
-  availableExports;
-  constructor(exportName, availableExports) {
-    super(`Export "${exportName}" not found. Available exports: ${availableExports.length > 0 ? availableExports.join(", ") : "(none)"}`);
-    this.exportName = exportName;
-    this.availableExports = availableExports;
-    this.name = "ExportNotFoundError";
-  }
-}
-function createModuleUrl(result) {
-  const blob = new Blob([result.code], { type: "application/javascript" });
-  return URL.createObjectURL(blob);
-}
-function revokeModuleUrl(url) {
-  URL.revokeObjectURL(url);
-}
-async function loadModule(result) {
-  const url = createModuleUrl(result);
-  try {
-    const module = await import(url);
-    return module;
-  } catch (err) {
-    throw new ModuleLoadError(`Failed to load module: ${err instanceof Error ? err.message : String(err)}`, err);
-  } finally {
-    revokeModuleUrl(url);
-  }
-}
-async function loadExport(result, exportName = "default") {
-  const module = await loadModule(result);
-  if (!(exportName in module)) {
-    const availableExports = Object.keys(module).filter((key) => !key.startsWith("__"));
-    throw new ExportNotFoundError(exportName, availableExports);
-  }
-  return module[exportName];
-}
-async function loadDefault(result) {
-  return loadExport(result, "default");
-}
-async function getExportNames(result) {
-  const module = await loadModule(result);
-  return Object.keys(module).filter((key) => !key.startsWith("__"));
-}
-async function hasExport(result, exportName) {
-  const module = await loadModule(result);
-  return exportName in module;
-}
-// src/packages.ts
-var ESM_CDN_BASE = "https://esm.sh";
-var KNOWN_SUBPATHS = {
-  react: ["jsx-runtime", "jsx-dev-runtime"],
-  "react-dom": ["client", "server"]
-};
-
-class InMemoryTypesCache {
-  cache = new Map;
-  key(name, version) {
-    return `${name}@${version}`;
-  }
-  get(name, version) {
-    return this.cache.get(this.key(name, version)) ?? null;
-  }
-  set(name, version, types) {
-    this.cache.set(this.key(name, version), types);
-  }
-  has(name, version) {
-    return this.cache.has(this.key(name, version));
-  }
-  delete(name, version) {
-    return this.cache.delete(this.key(name, version));
-  }
-  clear() {
-    this.cache.clear();
-  }
-  get size() {
-    return this.cache.size;
-  }
-}
-var PACKAGE_JSON_PATH = "/package.json";
-function parsePackageSpec(spec) {
-  if (spec.startsWith("@")) {
-    const slashIndex = spec.indexOf("/");
-    if (slashIndex === -1) {
-      return { name: spec };
-    }
-    const afterSlash = spec.slice(slashIndex + 1);
-    const atIndex2 = afterSlash.indexOf("@");
-    if (atIndex2 === -1) {
-      return { name: spec };
-    }
-    return {
-      name: spec.slice(0, slashIndex + 1 + atIndex2),
-      version: afterSlash.slice(atIndex2 + 1)
-    };
-  }
-  const atIndex = spec.indexOf("@");
-  if (atIndex === -1) {
-    return { name: spec };
-  }
-  return {
-    name: spec.slice(0, atIndex),
-    version: spec.slice(atIndex + 1)
-  };
-}
-function isTypesPackage(name) {
-  return name.startsWith("@types/");
-}
-function extractVersionFromUrl(url, packageName) {
-  const exactRegex = new RegExp(`${escapeRegExp(packageName)}@([^/]+)`);
-  const exactMatch = url.match(exactRegex);
-  if (exactMatch?.[1]) {
-    return exactMatch[1];
-  }
-  if (packageName.startsWith("@")) {
-    const scopedParts = packageName.split("/");
-    if (scopedParts.length === 2 && scopedParts[1]) {
-      const partialRegex = new RegExp(`${escapeRegExp(scopedParts[1])}@([^/]+)`);
-      const partialMatch = url.match(partialRegex);
-      if (partialMatch?.[1]) {
-        return partialMatch[1];
-      }
-    }
-  }
-  const genericMatch = url.match(/@(\d+\.\d+\.\d+[^/]*)/);
-  if (genericMatch?.[1]) {
-    return genericMatch[1];
-  }
-  return null;
-}
-async function fetchVersionFromNpm(name) {
-  const registryUrl = `https://registry.npmjs.org/${name}/latest`;
-  const response = await fetch(registryUrl);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch version from npm: ${response.status}`);
-  }
-  const data = await response.json();
-  return data.version;
-}
-function extractVersionFromHeaders(headers, packageName) {
-  const esmId = headers.get("x-esm-id");
-  if (esmId) {
-    const version = extractVersionFromUrl(esmId, packageName);
-    if (version)
-      return version;
-  }
-  const typesHeader = headers.get("X-TypeScript-Types");
-  if (typesHeader) {
-    const versionMatch = typesHeader.match(/@(\d+\.\d+\.\d+[^/]*)/);
-    if (versionMatch?.[1]) {
-      return versionMatch[1];
-    }
-  }
-  return null;
-}
-async function fetchPackageInfo(name, version, subpath) {
-  let url = version ? `${ESM_CDN_BASE}/${name}@${version}` : `${ESM_CDN_BASE}/${name}`;
-  if (subpath) {
-    url += `/${subpath}`;
-  }
-  const response = await fetch(url, { method: "HEAD" });
-  if (!response.ok) {
-    throw new Error(`Package not found: ${name}${version ? `@${version}` : ""}${subpath ? `/${subpath}` : ""}`);
-  }
-  const resolvedUrl = response.url;
-  let resolvedVersion = extractVersionFromUrl(resolvedUrl, name);
-  if (!resolvedVersion) {
-    resolvedVersion = extractVersionFromHeaders(response.headers, name);
-  }
-  if (!resolvedVersion && version && version !== "latest") {
-    resolvedVersion = version;
-  }
-  if (!resolvedVersion) {
-    try {
-      resolvedVersion = await fetchVersionFromNpm(name);
-    } catch (err) {
-      console.warn(`Could not resolve version for ${name}:`, err);
-      resolvedVersion = "latest";
-    }
-  }
-  const typesUrl = response.headers.get("X-TypeScript-Types") ?? undefined;
-  return {
-    version: resolvedVersion,
-    typesUrl: typesUrl ? new URL(typesUrl, resolvedUrl).href : undefined
-  };
-}
-function escapeRegExp(string) {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-async function fetchTypeDefinitions(typesUrl, packageName) {
-  const types = new Map;
-  try {
-    const response = await fetch(typesUrl);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch types: ${response.status}`);
-    }
-    const content = await response.text();
-    const typePath = `/node_modules/${packageName}/index.d.ts`;
-    types.set(typePath, content);
-    const refs = parseTypeReferences(content);
-    await fetchReferencedTypes(refs, typesUrl, packageName, types);
-  } catch (err) {
-    console.warn(`Failed to fetch types for ${packageName}:`, err);
-    throw err;
-  }
-  return types;
-}
-function parseTypeReferences(content) {
-  const paths = [];
-  const types = [];
-  const pathRegex = /\/\/\/\s*<reference\s+path="([^"]+)"\s*\/>/g;
-  let match;
-  while ((match = pathRegex.exec(content)) !== null) {
-    if (match[1])
-      paths.push(match[1]);
-  }
-  const typesRegex = /\/\/\/\s*<reference\s+types="([^"]+)"\s*\/>/g;
-  while ((match = typesRegex.exec(content)) !== null) {
-    if (match[1])
-      types.push(match[1]);
-  }
-  return { paths, types };
-}
-async function fetchReferencedTypes(refs, baseUrl, packageName, collected, visited = new Set) {
-  for (const pathRef of refs.paths) {
-    const refUrl = new URL(pathRef, baseUrl).href;
-    if (visited.has(refUrl))
-      continue;
-    visited.add(refUrl);
-    try {
-      const response = await fetch(refUrl);
-      if (!response.ok)
-        continue;
-      const content = await response.text();
-      const fileName = pathRef.split("/").pop() ?? "types.d.ts";
-      const typePath = `/node_modules/${packageName}/${fileName}`;
-      collected.set(typePath, content);
-      const nestedRefs = parseTypeReferences(content);
-      await fetchReferencedTypes(nestedRefs, refUrl, packageName, collected, visited);
-    } catch {}
-  }
-}
-async function fetchSubpathTypes(packageName, subpath, version) {
-  const types = new Map;
-  try {
-    const info = await fetchPackageInfo(packageName, version, subpath);
-    if (!info.typesUrl) {
-      return types;
-    }
-    const response = await fetch(info.typesUrl);
-    if (!response.ok) {
-      return types;
-    }
-    const content = await response.text();
-    const typePath = `/node_modules/${packageName}/${subpath}.d.ts`;
-    types.set(typePath, content);
-    const indexTypePath = `/node_modules/${packageName}/${subpath}/index.d.ts`;
-    types.set(indexTypePath, content);
-    const refs = parseTypeReferences(content);
-    await fetchReferencedTypes(refs, info.typesUrl, packageName, types);
-  } catch (err) {
-    console.warn(`Failed to fetch types for ${packageName}/${subpath}:`, err);
-  }
-  return types;
-}
-async function fetchTypesPackageContent(name, version) {
-  const url = version ? `${ESM_CDN_BASE}/${name}@${version}` : `${ESM_CDN_BASE}/${name}`;
-  const headResponse = await fetch(url, { method: "HEAD" });
-  if (!headResponse.ok) {
-    throw new Error(`Package not found: ${name}${version ? `@${version}` : ""}`);
-  }
-  const resolvedVersion = extractVersionFromUrl(headResponse.url, name) ?? version ?? "latest";
-  const indexUrl = `${ESM_CDN_BASE}/${name}@${resolvedVersion}/index.d.ts`;
-  const response = await fetch(indexUrl);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch types from ${name}: ${response.status}`);
-  }
-  const content = await response.text();
-  const types = new Map;
-  const typePath = `/node_modules/${name}/index.d.ts`;
-  types.set(typePath, content);
-  const refs = parseTypeReferences(content);
-  for (const pathRef of refs.paths) {
-    try {
-      const refUrl = new URL(pathRef, indexUrl).href;
-      const refResponse = await fetch(refUrl);
-      if (refResponse.ok) {
-        const refContent = await refResponse.text();
-        const fileName = pathRef.startsWith("./") ? pathRef.slice(2) : pathRef;
-        const refTypePath = `/node_modules/${name}/${fileName}`;
-        types.set(refTypePath, refContent);
-      }
-    } catch {}
-  }
-  return { version: resolvedVersion, types };
-}
-async function getPackageManifest(fs) {
-  try {
-    if (await fs.exists(PACKAGE_JSON_PATH)) {
-      const content = await fs.readFile(PACKAGE_JSON_PATH);
-      const parsed = JSON.parse(content);
-      return {
-        dependencies: parsed.dependencies ?? {}
-      };
-    }
-  } catch {}
-  return { dependencies: {} };
-}
-async function savePackageManifest(fs, manifest) {
-  let existing = {};
-  try {
-    if (await fs.exists(PACKAGE_JSON_PATH)) {
-      const content = await fs.readFile(PACKAGE_JSON_PATH);
-      existing = JSON.parse(content);
-    }
-  } catch {}
-  const updated = {
-    ...existing,
-    dependencies: manifest.dependencies
-  };
-  await fs.writeFile(PACKAGE_JSON_PATH, JSON.stringify(updated, null, 2));
-}
-async function installPackage(fs, packageSpec, options) {
-  const { name, version } = parsePackageSpec(packageSpec);
-  const { cache } = options ?? {};
-  if (isTypesPackage(name)) {
-    return installTypesPackage(fs, name, version, cache);
-  }
-  const info = await fetchPackageInfo(name, version);
-  const packageDir = `/node_modules/${name}`;
-  await ensureDir(fs, packageDir);
-  const packageJsonPath = `${packageDir}/package.json`;
-  const packageJson = {
-    name,
-    version: info.version,
-    types: "./index.d.ts",
-    main: "./index.js"
-  };
-  await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
-  let typeFiles = null;
-  let fromCache = false;
-  if (cache) {
-    typeFiles = cache.get(name, info.version);
-    if (typeFiles) {
-      fromCache = true;
-    }
-  }
-  let typesError;
-  if (!typeFiles) {
-    typeFiles = new Map;
-    if (info.typesUrl) {
-      try {
-        const mainTypes = await fetchTypeDefinitions(info.typesUrl, name);
-        for (const [path, content] of mainTypes) {
-          typeFiles.set(path, content);
-        }
-      } catch (err) {
-        typesError = err instanceof Error ? err.message : String(err);
-      }
-    } else {
-      typesError = "No TypeScript types available from esm.sh";
-    }
-    const knownSubpaths = KNOWN_SUBPATHS[name];
-    if (knownSubpaths && knownSubpaths.length > 0) {
-      const subpathResults = await Promise.allSettled(knownSubpaths.map((subpath) => fetchSubpathTypes(name, subpath, info.version)));
-      for (const result of subpathResults) {
-        if (result.status === "fulfilled") {
-          for (const [path, content] of result.value) {
-            typeFiles.set(path, content);
-          }
-        }
-      }
-    }
-    if (cache && typeFiles.size > 0) {
-      cache.set(name, info.version, typeFiles);
-    }
-  }
-  for (const [path, content] of typeFiles) {
-    const dir = path.substring(0, path.lastIndexOf("/"));
-    await ensureDir(fs, dir);
-    await fs.writeFile(path, content);
-  }
-  const manifest = await getPackageManifest(fs);
-  manifest.dependencies[name] = info.version;
-  await savePackageManifest(fs, manifest);
-  return {
-    name,
-    version: info.version,
-    typesInstalled: typeFiles.size > 0,
-    typeFilesCount: typeFiles.size,
-    typesError,
-    fromCache
-  };
-}
-async function installTypesPackage(fs, name, version, cache) {
-  const url = version ? `${ESM_CDN_BASE}/${name}@${version}` : `${ESM_CDN_BASE}/${name}`;
-  const headResponse = await fetch(url, { method: "HEAD" });
-  if (!headResponse.ok) {
-    throw new Error(`Package not found: ${name}${version ? `@${version}` : ""}`);
-  }
-  const resolvedVersion = extractVersionFromUrl(headResponse.url, name) ?? version ?? "latest";
-  let types = null;
-  let fromCache = false;
-  if (cache) {
-    types = cache.get(name, resolvedVersion);
-    if (types) {
-      fromCache = true;
-    }
-  }
-  if (!types) {
-    const result = await fetchTypesPackageContent(name, version);
-    types = result.types;
-    if (cache && types.size > 0) {
-      cache.set(name, resolvedVersion, types);
-    }
-  }
-  const packageDir = `/node_modules/${name}`;
-  await ensureDir(fs, packageDir);
-  const packageJsonPath = `${packageDir}/package.json`;
-  const packageJson = {
-    name,
-    version: resolvedVersion,
-    types: "./index.d.ts"
-  };
-  await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
-  for (const [path, content] of types) {
-    const dir = path.substring(0, path.lastIndexOf("/"));
-    await ensureDir(fs, dir);
-    await fs.writeFile(path, content);
-  }
-  const manifest = await getPackageManifest(fs);
-  manifest.dependencies[name] = resolvedVersion;
-  await savePackageManifest(fs, manifest);
-  return {
-    name,
-    version: resolvedVersion,
-    typesInstalled: types.size > 0,
-    typeFilesCount: types.size,
-    fromCache
-  };
-}
-async function ensureDir(fs, path) {
-  if (path === "/" || path === "")
-    return;
-  if (await fs.exists(path)) {
-    const stat = await fs.stat(path);
-    if (stat.isDirectory)
-      return;
-  }
-  const parent = path.substring(0, path.lastIndexOf("/")) || "/";
-  await ensureDir(fs, parent);
-  await fs.mkdir(path);
-}
-async function uninstallPackage(fs, packageName) {
-  const manifest = await getPackageManifest(fs);
-  if (!(packageName in manifest.dependencies)) {
-    return false;
-  }
-  delete manifest.dependencies[packageName];
-  await savePackageManifest(fs, manifest);
-  const typesPath = `/node_modules/${packageName}`;
-  if (await fs.exists(typesPath)) {
-    await removePath(fs, typesPath);
-  }
-  return true;
-}
-async function removePath(fs, path) {
-  if (!await fs.exists(path))
-    return;
-  await fs.rm(path, { recursive: true, force: true });
-}
-function resolveToEsmUrl(importPath, installedPackages) {
-  const { packageName, subpath } = parseImportPath(importPath);
-  const version = installedPackages[packageName];
-  if (!version) {
-    return null;
-  }
-  const baseUrl = `${ESM_CDN_BASE}/${packageName}@${version}`;
-  return subpath ? `${baseUrl}/${subpath}` : baseUrl;
-}
-function parseImportPath(importPath) {
-  if (importPath.startsWith("@")) {
-    const parts = importPath.split("/");
-    if (parts.length >= 2) {
-      const packageName = `${parts[0]}/${parts[1]}`;
-      const subpath = parts.slice(2).join("/") || undefined;
-      return { packageName, subpath };
-    }
-    return { packageName: importPath };
-  }
-  const slashIndex = importPath.indexOf("/");
-  if (slashIndex === -1) {
-    return { packageName: importPath };
-  }
-  return {
-    packageName: importPath.slice(0, slashIndex),
-    subpath: importPath.slice(slashIndex + 1)
-  };
-}
-async function listPackages(fs) {
-  const manifest = await getPackageManifest(fs);
-  return Object.entries(manifest.dependencies).map(([name, version]) => ({
-    name,
-    version
-  }));
-}
-// src/ts-libs.ts
-var TS_VERSION = "5.9.3";
-var CDN_BASE = `https://cdn.jsdelivr.net/npm/typescript@${TS_VERSION}/lib`;
-function getDefaultBrowserLibs() {
-  return ["es2020", "dom", "dom.iterable"];
-}
-function parseLibReferences(content) {
-  const refs = [];
-  const regex = /\/\/\/\s*<reference\s+lib="([^"]+)"\s*\/>/g;
-  let match;
-  while ((match = regex.exec(content)) !== null) {
-    if (match[1]) {
-      refs.push(match[1]);
-    }
-  }
-  return refs;
-}
-function libNameToFileName(name) {
-  return `lib.${name}.d.ts`;
-}
-function extractLibName(filePath) {
-  const match = filePath.match(/lib\.([^/]+)\.d\.ts$/);
-  return match?.[1] ?? null;
-}
-async function fetchLibFile(name) {
-  const fileName = libNameToFileName(name);
-  const url = `${CDN_BASE}/${fileName}`;
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
-  }
-  return response.text();
-}
-async function fetchAllLibs(libs) {
-  const result = new Map;
-  const pending = new Set(libs);
-  const fetched = new Set;
-  while (pending.size > 0) {
-    const batch = Array.from(pending);
-    pending.clear();
-    const results = await Promise.all(batch.map(async (name) => {
-      if (fetched.has(name)) {
-        return { name, content: null };
-      }
-      fetched.add(name);
-      try {
-        const content = await fetchLibFile(name);
-        return { name, content };
-      } catch (err) {
-        console.warn(`Failed to fetch lib.${name}.d.ts:`, err);
-        return { name, content: null };
-      }
-    }));
-    for (const { name, content } of results) {
-      if (content === null)
-        continue;
-      result.set(name, content);
-      const refs = parseLibReferences(content);
-      for (const ref of refs) {
-        if (!fetched.has(ref) && !pending.has(ref)) {
-          pending.add(ref);
-        }
-      }
-    }
-  }
-  return result;
-}
-var memoryCache = null;
-
-class LibCache {
-  async getOrFetch(libs) {
-    if (memoryCache) {
-      const missing = libs.filter((lib) => !memoryCache.has(lib));
-      if (missing.length === 0) {
-        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`);
-    memoryCache = fetched;
-    return fetched;
-  }
-  get() {
-    return memoryCache;
-  }
-  set(libs) {
-    memoryCache = libs;
-  }
-  clear() {
-    memoryCache = null;
-  }
-}
-async function fetchAndCacheLibs(libs = getDefaultBrowserLibs()) {
-  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.register(id, mod);
-    }
-    return this;
-  }
-  unregister(moduleId) {
-    return this.modules.delete(moduleId);
-  }
-  get(moduleId) {
-    const mod = this.modules.get(moduleId);
-    if (mod === undefined && !this.modules.has(moduleId)) {
-      const available = this.list();
-      throw new Error(`Shared module "${moduleId}" not registered. ` + `Available: ${available.length > 0 ? available.join(", ") : "(none)"}. ` + `Call registerSharedModules({ '${moduleId}': ... }) in your host application.`);
-    }
-    return mod;
-  }
-  has(moduleId) {
-    return this.modules.has(moduleId);
-  }
-  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) {
-    defaultRegistry = new SharedModuleRegistry;
-  }
-  return defaultRegistry;
-}
-function hasSharedModuleRegistry() {
-  return GLOBAL_KEY in globalThis;
-}
-function registerSharedModules(modules) {
-  getSharedModuleRegistry().registerAll(modules);
-}
-function unregisterSharedModule(moduleId) {
-  return getSharedModuleRegistry().unregister(moduleId);
-}
-function clearSharedModules() {
-  getSharedModuleRegistry().clear();
-}
-function getSharedModuleExports(moduleId) {
-  return getSharedModuleRegistry().getExportNames(moduleId);
-}
-function getSharedModuleRuntimeCode(moduleId) {
-  return `
-(function() {
-  var registry = globalThis["${GLOBAL_KEY}"];
-  if (!registry) {
-    throw new Error(
-      'Sandlot SharedModuleRegistry not found. ' +
-      'Call registerSharedModules() in your host application before loading dynamic modules.'
-    );
-  }
-  return registry.get(${JSON.stringify(moduleId)});
-})()
-`.trim();
-}
-// 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
-import ts from "typescript";
-function categoryToString(category) {
-  switch (category) {
-    case ts.DiagnosticCategory.Error:
-      return "error";
-    case ts.DiagnosticCategory.Warning:
-      return "warning";
-    case ts.DiagnosticCategory.Suggestion:
-      return "suggestion";
-    case ts.DiagnosticCategory.Message:
-      return "message";
-    default:
-      return "error";
-  }
-}
-function convertDiagnostic(diag) {
-  let file = null;
-  let line = null;
-  let column = null;
-  if (diag.file && diag.start !== undefined) {
-    file = diag.file.fileName;
-    const pos = diag.file.getLineAndCharacterOfPosition(diag.start);
-    line = pos.line + 1;
-    column = pos.character + 1;
-  }
-  return {
-    file,
-    line,
-    column,
-    code: diag.code,
-    category: categoryToString(diag.category),
-    message: ts.flattenDiagnosticMessageText(diag.messageText, `
-`)
-  };
-}
-function normalizePath(path) {
-  if (!path.startsWith("/")) {
-    return "/" + path;
-  }
-  return path;
-}
-async function preloadFiles(fs) {
-  const cache = new Map;
-  const allPaths = fs.getAllPaths();
-  for (const path of allPaths) {
-    if (path.endsWith(".ts") || path.endsWith(".tsx") || path.endsWith(".js") || path.endsWith(".jsx") || path.endsWith(".json") || path.endsWith(".d.ts")) {
-      try {
-        const stat = await fs.stat(path);
-        if (stat.isFile) {
-          const content = await fs.readFile(path);
-          cache.set(path, content);
-        }
-      } catch {}
-    }
-  }
-  return cache;
-}
-function parseTsConfig(configText, _configPath) {
-  try {
-    const config = JSON.parse(configText);
-    const compilerOptions = config.compilerOptions || {};
-    const options = {
-      ...getDefaultCompilerOptions()
-    };
-    if (compilerOptions.target) {
-      const targetMap = {
-        es5: ts.ScriptTarget.ES5,
-        es6: ts.ScriptTarget.ES2015,
-        es2015: ts.ScriptTarget.ES2015,
-        es2016: ts.ScriptTarget.ES2016,
-        es2017: ts.ScriptTarget.ES2017,
-        es2018: ts.ScriptTarget.ES2018,
-        es2019: ts.ScriptTarget.ES2019,
-        es2020: ts.ScriptTarget.ES2020,
-        es2021: ts.ScriptTarget.ES2021,
-        es2022: ts.ScriptTarget.ES2022,
-        esnext: ts.ScriptTarget.ESNext
-      };
-      options.target = targetMap[compilerOptions.target.toLowerCase()] ?? ts.ScriptTarget.ES2020;
-    }
-    if (compilerOptions.module) {
-      const moduleMap = {
-        commonjs: ts.ModuleKind.CommonJS,
-        amd: ts.ModuleKind.AMD,
-        umd: ts.ModuleKind.UMD,
-        system: ts.ModuleKind.System,
-        es6: ts.ModuleKind.ES2015,
-        es2015: ts.ModuleKind.ES2015,
-        es2020: ts.ModuleKind.ES2020,
-        es2022: ts.ModuleKind.ES2022,
-        esnext: ts.ModuleKind.ESNext,
-        node16: ts.ModuleKind.Node16,
-        nodenext: ts.ModuleKind.NodeNext
-      };
-      options.module = moduleMap[compilerOptions.module.toLowerCase()] ?? ts.ModuleKind.ESNext;
-    }
-    if (compilerOptions.moduleResolution) {
-      const resolutionMap = {
-        classic: ts.ModuleResolutionKind.Classic,
-        node: ts.ModuleResolutionKind.NodeJs,
-        node10: ts.ModuleResolutionKind.NodeJs,
-        node16: ts.ModuleResolutionKind.Node16,
-        nodenext: ts.ModuleResolutionKind.NodeNext,
-        bundler: ts.ModuleResolutionKind.Bundler
-      };
-      options.moduleResolution = resolutionMap[compilerOptions.moduleResolution.toLowerCase()] ?? ts.ModuleResolutionKind.Bundler;
-    }
-    if (compilerOptions.jsx) {
-      const jsxMap = {
-        preserve: ts.JsxEmit.Preserve,
-        react: ts.JsxEmit.React,
-        "react-jsx": ts.JsxEmit.ReactJSX,
-        "react-jsxdev": ts.JsxEmit.ReactJSXDev,
-        "react-native": ts.JsxEmit.ReactNative
-      };
-      options.jsx = jsxMap[compilerOptions.jsx.toLowerCase()] ?? ts.JsxEmit.ReactJSX;
-    }
-    if (compilerOptions.strict !== undefined)
-      options.strict = compilerOptions.strict;
-    if (compilerOptions.esModuleInterop !== undefined)
-      options.esModuleInterop = compilerOptions.esModuleInterop;
-    if (compilerOptions.skipLibCheck !== undefined)
-      options.skipLibCheck = compilerOptions.skipLibCheck;
-    if (compilerOptions.allowJs !== undefined)
-      options.allowJs = compilerOptions.allowJs;
-    if (compilerOptions.resolveJsonModule !== undefined)
-      options.resolveJsonModule = compilerOptions.resolveJsonModule;
-    if (compilerOptions.noImplicitAny !== undefined)
-      options.noImplicitAny = compilerOptions.noImplicitAny;
-    if (compilerOptions.strictNullChecks !== undefined)
-      options.strictNullChecks = compilerOptions.strictNullChecks;
-    if (Array.isArray(compilerOptions.lib)) {
-      options.lib = compilerOptions.lib.map((lib) => lib.toLowerCase().startsWith("lib.") ? lib : `lib.${lib.toLowerCase()}.d.ts`);
-    }
-    options.noEmit = true;
-    return options;
-  } catch (err) {
-    console.warn("Error parsing tsconfig.json:", err);
-    return getDefaultCompilerOptions();
-  }
-}
-function getDefaultCompilerOptions() {
-  return {
-    target: ts.ScriptTarget.ES2020,
-    module: ts.ModuleKind.ESNext,
-    moduleResolution: ts.ModuleResolutionKind.Bundler,
-    esModuleInterop: true,
-    strict: true,
-    skipLibCheck: true,
-    noEmit: true,
-    jsx: ts.JsxEmit.ReactJSX,
-    allowJs: true,
-    resolveJsonModule: true,
-    noLib: false,
-    lib: [
-      "lib.es2020.d.ts",
-      "lib.dom.d.ts",
-      "lib.dom.iterable.d.ts"
-    ]
-  };
-}
-var LIB_PATH_PREFIX = "/node_modules/typescript/lib/";
-function createVfsCompilerHost(fileCache, libFiles, _options) {
-  function getLibContent(fileName) {
-    const libMatch = fileName.match(/lib\.([^/]+)\.d\.ts$/);
-    if (libMatch && libMatch[1]) {
-      return libFiles.get(libMatch[1]);
-    }
-    return;
-  }
-  return {
-    getSourceFile(fileName, languageVersion, onError) {
-      const normalizedPath = normalizePath(fileName);
-      const content = fileCache.get(normalizedPath);
-      if (content !== undefined) {
-        return ts.createSourceFile(normalizedPath, content, languageVersion, true);
-      }
-      const altContent = fileCache.get(fileName);
-      if (altContent !== undefined) {
-        return ts.createSourceFile(fileName, altContent, languageVersion, true);
-      }
-      const libContent = getLibContent(fileName);
-      if (libContent !== undefined) {
-        return ts.createSourceFile(fileName, libContent, languageVersion, true);
-      }
-      if (onError) {
-        onError(`File not found: ${fileName}`);
-      }
-      return;
-    },
-    getDefaultLibFileName(options) {
-      return LIB_PATH_PREFIX + ts.getDefaultLibFileName(options);
-    },
-    writeFile() {},
-    getCurrentDirectory() {
-      return "/";
-    },
-    getCanonicalFileName(fileName) {
-      return fileName;
-    },
-    useCaseSensitiveFileNames() {
-      return true;
-    },
-    getNewLine() {
-      return `
-`;
-    },
-    fileExists(fileName) {
-      const normalizedPath = normalizePath(fileName);
-      if (fileCache.has(normalizedPath) || fileCache.has(fileName)) {
-        return true;
-      }
-      return getLibContent(fileName) !== undefined;
-    },
-    readFile(fileName) {
-      const normalizedPath = normalizePath(fileName);
-      const content = fileCache.get(normalizedPath) ?? fileCache.get(fileName);
-      if (content !== undefined) {
-        return content;
-      }
-      return getLibContent(fileName);
-    },
-    directoryExists(directoryName) {
-      const normalizedDir = normalizePath(directoryName);
-      for (const path of fileCache.keys()) {
-        if (path.startsWith(normalizedDir + "/")) {
-          return true;
-        }
-      }
-      if (normalizedDir === "/node_modules/typescript/lib" || normalizedDir === "/node_modules/typescript") {
-        return libFiles.size > 0;
-      }
-      if (normalizedDir === "/node_modules") {
-        return libFiles.size > 0 || Array.from(fileCache.keys()).some((p) => p.startsWith("/node_modules/"));
-      }
-      if (normalizedDir === "/node_modules/@types") {
-        return Array.from(fileCache.keys()).some((p) => p.startsWith("/node_modules/@types/"));
-      }
-      return false;
-    },
-    getDirectories(path) {
-      const normalizedPath = normalizePath(path);
-      const prefix = normalizedPath === "/" ? "/" : normalizedPath + "/";
-      const dirs = new Set;
-      for (const filePath of fileCache.keys()) {
-        if (filePath.startsWith(prefix)) {
-          const relative = filePath.slice(prefix.length);
-          const firstSlash = relative.indexOf("/");
-          if (firstSlash > 0) {
-            dirs.add(relative.slice(0, firstSlash));
-          }
-        }
-      }
-      if (normalizedPath === "/") {
-        const hasNodeModules = libFiles.size > 0 || Array.from(fileCache.keys()).some((p) => p.startsWith("/node_modules/"));
-        if (hasNodeModules) {
-          dirs.add("node_modules");
-        }
-      }
-      return Array.from(dirs);
-    },
-    realpath(path) {
-      return path;
-    },
-    getEnvironmentVariable() {
-      return;
-    }
-  };
-}
-async function typecheck(options) {
-  const {
-    fs,
-    entryPoint,
-    tsconfigPath = "/tsconfig.json",
-    libFiles = new Map
-  } = options;
-  const normalizedEntry = normalizePath(entryPoint);
-  if (!await fs.exists(normalizedEntry)) {
-    throw new Error(`Entry point not found: ${normalizedEntry}`);
-  }
-  const fileCache = await preloadFiles(fs);
-  let compilerOptions = getDefaultCompilerOptions();
-  const tsconfigContent = fileCache.get(normalizePath(tsconfigPath));
-  if (tsconfigContent) {
-    compilerOptions = {
-      ...parseTsConfig(tsconfigContent, tsconfigPath),
-      noEmit: true
-    };
-  }
-  const host = createVfsCompilerHost(fileCache, libFiles, compilerOptions);
-  const program = ts.createProgram([normalizedEntry], compilerOptions, host);
-  const allDiagnostics = [
-    ...program.getSyntacticDiagnostics(),
-    ...program.getSemanticDiagnostics(),
-    ...program.getDeclarationDiagnostics()
-  ];
-  const diagnostics = allDiagnostics.map(convertDiagnostic);
-  const checkedFiles = program.getSourceFiles().map((sf) => sf.fileName).filter((f) => !f.includes("node_modules/typescript/lib"));
-  const hasErrors = diagnostics.some((d) => d.category === "error");
-  return {
-    diagnostics,
-    hasErrors,
-    checkedFiles
-  };
-}
-function formatDiagnostics(diagnostics) {
-  return diagnostics.map((d) => {
-    const location = d.file ? `${d.file}${d.line ? `:${d.line}` : ""}${d.column ? `:${d.column}` : ""}` : "(global)";
-    return `${location} - ${d.category} TS${d.code}: ${d.message}`;
-  }).join(`
-`);
-}
-function formatDiagnosticsForAgent(diagnostics) {
-  if (diagnostics.length === 0) {
-    return "No type errors found.";
-  }
-  const errorCount = diagnostics.filter((d) => d.category === "error").length;
-  const warningCount = diagnostics.filter((d) => d.category === "warning").length;
-  const summary = errorCount > 0 || warningCount > 0 ? `Found ${errorCount} error(s) and ${warningCount} warning(s):
-
-` : "";
-  const formatted = diagnostics.map((d) => {
-    const location = d.file ? `${d.file}${d.line ? ` at line ${d.line}` : ""}` : "Global";
-    const prefix = d.category === "error" ? "Error" : d.category === "warning" ? "Warning" : "Info";
-    return `${prefix} in ${location}: ${d.message} (TS${d.code})`;
-  }).join(`
-
-`);
-  return summary + formatted;
-}
-
-// 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;
-  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;
-}
-var ESBUILD_VERSION = "0.27.2";
-var initialized = false;
-var initPromise = null;
-function getWasmUrl() {
-  return `https://unpkg.com/esbuild-wasm@${ESBUILD_VERSION}/esbuild.wasm`;
-}
-function checkCrossOriginIsolation() {
-  if (typeof window === "undefined")
-    return;
-  if (!window.crossOriginIsolated) {
-    console.warn(`[sandlot] Cross-origin isolation is not enabled. esbuild-wasm may have reduced performance or fail on some browsers.
-To enable, add these headers to your dev server:
-  Cross-Origin-Embedder-Policy: require-corp
-  Cross-Origin-Opener-Policy: same-origin
-In Vite, add a plugin to configureServer. See sandlot README for details.`);
-  }
-}
-async function initBundler() {
-  if (initialized)
-    return;
-  if (initPromise) {
-    await initPromise;
-    return;
-  }
-  initPromise = (async () => {
-    const es = await getEsbuild();
-    if (!isServerEnvironment() && typeof es.initialize === "function") {
-      checkCrossOriginIsolation();
-      await es.initialize({
-        wasmURL: getWasmUrl()
-      });
-    }
-  })();
-  await initPromise;
-  initialized = true;
-}
-function isBareImport(path) {
-  return !path.startsWith(".") && !path.startsWith("/");
-}
-function getLoader(path) {
-  const ext = path.split(".").pop()?.toLowerCase();
-  switch (ext) {
-    case "ts":
-      return "ts";
-    case "tsx":
-      return "tsx";
-    case "jsx":
-      return "jsx";
-    case "js":
-    case "mjs":
-      return "js";
-    case "json":
-      return "json";
-    case "css":
-      return "css";
-    case "txt":
-      return "text";
-    default:
-      return "js";
-  }
-}
-function matchesSharedModule(importPath, sharedModuleIds) {
-  if (sharedModuleIds.has(importPath)) {
-    return importPath;
-  }
-  for (const moduleId of sharedModuleIds) {
-    if (importPath === moduleId || importPath.startsWith(moduleId + "/")) {
-      return importPath;
-    }
-  }
-  return null;
-}
-function createVfsPlugin(options) {
-  const {
-    fs,
-    entryPoint,
-    npmImports,
-    installedPackages,
-    includedFiles,
-    sharedModuleIds
-  } = options;
-  return {
-    name: "virtual-fs",
-    setup(build) {
-      build.onResolve({ filter: /.*/ }, async (args) => {
-        if (args.kind === "entry-point") {
-          return { path: entryPoint, namespace: "vfs" };
-        }
-        if (isBareImport(args.path)) {
-          const sharedMatch = matchesSharedModule(args.path, sharedModuleIds);
-          if (sharedMatch) {
-            return {
-              path: sharedMatch,
-              namespace: "sandlot-shared"
-            };
-          }
-          switch (npmImports) {
-            case "cdn": {
-              const esmUrl = resolveToEsmUrl(args.path, installedPackages);
-              if (esmUrl) {
-                return { path: esmUrl, external: true };
-              }
-              return { path: args.path, external: true };
-            }
-            case "external":
-              return { path: args.path, external: true };
-            case "bundle": {
-              const resolved2 = fs.resolvePath(args.resolveDir, `node_modules/${args.path}`);
-              const exists = await fs.exists(resolved2);
-              if (exists) {
-                return { path: resolved2, namespace: "vfs" };
-              }
-              return { path: args.path, external: true };
-            }
-          }
-        }
-        const resolved = fs.resolvePath(args.resolveDir, args.path);
-        const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".json"];
-        const hasExtension = extensions.some((ext) => resolved.endsWith(ext));
-        if (hasExtension) {
-          const exists = await fs.exists(resolved);
-          if (exists) {
-            return { path: resolved, namespace: "vfs" };
-          }
-          return { errors: [{ text: `File not found: ${resolved}` }] };
-        }
-        for (const ext of extensions) {
-          const withExt = resolved + ext;
-          if (await fs.exists(withExt)) {
-            return { path: withExt, namespace: "vfs" };
-          }
-        }
-        for (const ext of extensions) {
-          const indexPath = `${resolved}/index${ext}`;
-          if (await fs.exists(indexPath)) {
-            return { path: indexPath, namespace: "vfs" };
-          }
-        }
-        return { errors: [{ text: `Cannot resolve: ${args.path} from ${args.resolveDir}` }] };
-      });
-      build.onLoad({ filter: /.*/, namespace: "sandlot-shared" }, (args) => {
-        const contents = `
-const __sandlot_mod__ = ${getSharedModuleRuntimeCode(args.path)};
-export default __sandlot_mod__.default ?? __sandlot_mod__;
-${generateNamedExports(args.path)}
-`;
-        return {
-          contents: contents.trim(),
-          loader: "js"
-        };
-      });
-      build.onLoad({ filter: /.*/, namespace: "vfs" }, async (args) => {
-        try {
-          const contents = await fs.readFile(args.path);
-          includedFiles.add(args.path);
-          return {
-            contents,
-            loader: getLoader(args.path),
-            resolveDir: args.path.substring(0, args.path.lastIndexOf("/"))
-          };
-        } catch (err) {
-          return {
-            errors: [{ text: `Failed to read ${args.path}: ${err}` }]
-          };
-        }
-      });
-    }
-  };
-}
-function generateNamedExports(moduleId) {
-  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();
-  const {
-    fs,
-    entryPoint,
-    external = [],
-    npmImports = "cdn",
-    sharedModules = [],
-    format = "esm",
-    minify = false,
-    sourcemap = false,
-    globalName,
-    target = ["es2020"]
-  } = options;
-  const normalizedEntry = entryPoint.startsWith("/") ? entryPoint : `/${entryPoint}`;
-  if (!await fs.exists(normalizedEntry)) {
-    throw new Error(`Entry point not found: ${normalizedEntry}`);
-  }
-  const manifest = await getPackageManifest(fs);
-  const installedPackages = manifest.dependencies;
-  const sharedModuleIds = new Set(sharedModules);
-  const includedFiles = new Set;
-  const plugin = createVfsPlugin({
-    fs,
-    entryPoint: normalizedEntry,
-    npmImports,
-    installedPackages,
-    includedFiles,
-    sharedModuleIds
-  });
-  const es = await getEsbuild();
-  const result = await es.build({
-    entryPoints: [normalizedEntry],
-    bundle: true,
-    write: false,
-    format,
-    minify,
-    sourcemap: sourcemap ? "inline" : false,
-    globalName,
-    target,
-    external,
-    plugins: [plugin],
-    jsx: "automatic"
-  });
-  const code = result.outputFiles?.[0]?.text ?? "";
-  return {
-    code,
-    warnings: result.warnings,
-    includedFiles: Array.from(includedFiles)
-  };
-}
-async function bundleToUrl(options) {
-  const result = await bundle(options);
-  const blob = new Blob([result.code], { type: "application/javascript" });
-  return URL.createObjectURL(blob);
-}
-async function bundleAndImport(options) {
-  const url = await bundleToUrl(options);
-  try {
-    return await import(url);
-  } finally {
-    URL.revokeObjectURL(url);
-  }
-}
-
-// src/commands/compile.ts
-function createTscCommand(deps) {
-  const { fs, libFiles, tsconfigPath } = deps;
-  return defineCommand("tsc", async (args, _ctx) => {
-    const entryPoint = args[0];
-    if (!entryPoint) {
-      return {
-        stdout: "",
-        stderr: `Usage: tsc <entry-point>
-
-Example: tsc /src/index.ts
-`,
-        exitCode: 1
-      };
-    }
-    try {
-      if (!await fs.exists(entryPoint)) {
-        return {
-          stdout: "",
-          stderr: `Error: Entry point not found: ${entryPoint}
-`,
-          exitCode: 1
-        };
-      }
-      const result = await typecheck({
-        fs,
-        entryPoint,
-        tsconfigPath,
-        libFiles
-      });
-      if (result.hasErrors) {
-        const formatted = formatDiagnosticsForAgent(result.diagnostics);
-        return {
-          stdout: "",
-          stderr: formatted + `
-`,
-          exitCode: 1
-        };
-      }
-      const checkedCount = result.checkedFiles.length;
-      const warningCount = result.diagnostics.filter((d) => d.category === "warning").length;
-      let output = `Type check passed. Checked ${checkedCount} file(s).
-`;
-      if (warningCount > 0) {
-        output += `
-Warnings:
-${formatDiagnosticsForAgent(result.diagnostics.filter((d) => d.category === "warning"))}
-`;
-      }
-      return {
-        stdout: output,
-        stderr: "",
-        exitCode: 0
-      };
-    } catch (err) {
-      return {
-        stdout: "",
-        stderr: `Type check failed: ${err instanceof Error ? err.message : String(err)}
-`,
-        exitCode: 1
-      };
-    }
-  });
-}
-function createBuildCommand(deps) {
-  const { fs, libFiles, tsconfigPath, onBuild, getValidation, sharedModules } = deps;
-  return defineCommand("build", async (args, _ctx) => {
-    let entryPoint = null;
-    let skipTypecheck = false;
-    let minify = false;
-    let format = "esm";
-    for (let i = 0;i < args.length; i++) {
-      const arg = args[i];
-      if (arg === "--skip-typecheck" || arg === "-s") {
-        skipTypecheck = true;
-      } else if (arg === "--minify" || arg === "-m") {
-        minify = true;
-      } else if ((arg === "--format" || arg === "-f") && args[i + 1]) {
-        const f = args[++i].toLowerCase();
-        if (f === "esm" || f === "iife" || f === "cjs") {
-          format = f;
-        }
-      } else if (!arg.startsWith("-")) {
-        entryPoint = arg;
-      }
-    }
-    if (!entryPoint) {
-      return {
-        stdout: "",
-        stderr: `Usage: build <entry-point> [options]
-
-Options:
-  --skip-typecheck, -s  Skip type checking
-  --minify, -m          Minify output
-  --format, -f <fmt>    Output format (esm|iife|cjs)
-
-Example: build /src/index.ts
-`,
-        exitCode: 1
-      };
-    }
-    try {
-      if (!await fs.exists(entryPoint)) {
-        return {
-          stdout: "",
-          stderr: `Error: Entry point not found: ${entryPoint}
-`,
-          exitCode: 1
-        };
-      }
-      let typecheckResult = null;
-      if (!skipTypecheck) {
-        typecheckResult = await typecheck({
-          fs,
-          entryPoint,
-          tsconfigPath,
-          libFiles
-        });
-        if (typecheckResult.hasErrors) {
-          const formatted = formatDiagnosticsForAgent(typecheckResult.diagnostics);
-          return {
-            stdout: "",
-            stderr: `Build failed: Type errors found.
-
-${formatted}
-`,
-            exitCode: 1
-          };
-        }
-      }
-      const bundleResult = await bundle({
-        fs,
-        entryPoint,
-        format,
-        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({ bundle: bundleResult, module: validatedModule });
-      }
-      let output = `Build successful!
-`;
-      output += `Entry: ${entryPoint}
-`;
-      output += `Format: ${format}
-`;
-      output += `Size: ${(bundleResult.code.length / 1024).toFixed(2)} KB
-`;
-      if (typecheckResult) {
-        output += `Type checked: ${typecheckResult.checkedFiles.length} file(s)
-`;
-      }
-      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:
-${formatEsbuildMessages(bundleResult.warnings)}
-`;
-      }
-      if (typecheckResult) {
-        const warnings = typecheckResult.diagnostics.filter((d) => d.category === "warning");
-        if (warnings.length > 0) {
-          output += `
-Type warnings:
-${formatDiagnosticsForAgent(warnings)}
-`;
-        }
-      }
-      return {
-        stdout: output,
-        stderr: "",
-        exitCode: 0
-      };
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      return {
-        stdout: "",
-        stderr: `Build failed: ${errorMessage}
-`,
-        exitCode: 1
-      };
-    }
-  });
-}
-// src/commands/packages.ts
-import { defineCommand as defineCommand2 } from "just-bash/browser";
-function createInstallCommand(deps) {
-  const { fs, typesCache } = deps;
-  return defineCommand2("install", async (args, _ctx) => {
-    if (args.length === 0) {
-      return {
-        stdout: "",
-        stderr: `Usage: install <package>[@version] [...packages]
-
-Examples:
-  install react
-  install lodash@4.17.21
-  install @tanstack/react-query@5
-`,
-        exitCode: 1
-      };
-    }
-    const results = [];
-    let hasError = false;
-    for (const packageSpec of args) {
-      try {
-        const result = await installPackage(fs, packageSpec, { cache: typesCache });
-        let status = `+ ${result.name}@${result.version}`;
-        if (result.typesInstalled) {
-          status += ` (${result.typeFilesCount} type file${result.typeFilesCount !== 1 ? "s" : ""})`;
-          if (result.fromCache) {
-            status += " [cached]";
-          }
-        } else if (result.typesError) {
-          status += ` (no types: ${result.typesError})`;
-        }
-        results.push(status);
-      } catch (err) {
-        hasError = true;
-        const message = err instanceof Error ? err.message : String(err);
-        results.push(`x ${packageSpec}: ${message}`);
-      }
-    }
-    const output = results.join(`
-`) + `
-`;
-    if (hasError) {
-      return {
-        stdout: "",
-        stderr: output,
-        exitCode: 1
-      };
-    }
-    return {
-      stdout: output,
-      stderr: "",
-      exitCode: 0
-    };
-  });
-}
-function createUninstallCommand(deps) {
-  const { fs } = deps;
-  return defineCommand2("uninstall", async (args, _ctx) => {
-    if (args.length === 0) {
-      return {
-        stdout: "",
-        stderr: `Usage: uninstall <package> [...packages]
-`,
-        exitCode: 1
-      };
-    }
-    const results = [];
-    let hasError = false;
-    for (const packageName of args) {
-      try {
-        const removed = await uninstallPackage(fs, packageName);
-        if (removed) {
-          results.push(`- ${packageName}`);
-        } else {
-          results.push(`x ${packageName}: not installed`);
-          hasError = true;
-        }
-      } catch (err) {
-        hasError = true;
-        const message = err instanceof Error ? err.message : String(err);
-        results.push(`x ${packageName}: ${message}`);
-      }
-    }
-    const output = results.join(`
-`) + `
-`;
-    if (hasError) {
-      return {
-        stdout: "",
-        stderr: output,
-        exitCode: 1
-      };
-    }
-    return {
-      stdout: output,
-      stderr: "",
-      exitCode: 0
-    };
-  });
-}
-function createListCommand(deps) {
-  const { fs } = deps;
-  return defineCommand2("list", async (_args, _ctx) => {
-    try {
-      const packages = await listPackages(fs);
-      if (packages.length === 0) {
-        return {
-          stdout: `No packages installed.
-`,
-          stderr: "",
-          exitCode: 0
-        };
-      }
-      const output = packages.map((pkg) => `${pkg.name}@${pkg.version}`).join(`
-`) + `
-`;
-      return {
-        stdout: output,
-        stderr: "",
-        exitCode: 0
-      };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return {
-        stdout: "",
-        stderr: `Failed to list packages: ${message}
-`,
-        exitCode: 1
-      };
-    }
-  });
-}
-// src/commands/run.ts
-import { defineCommand as defineCommand3 } from "just-bash/browser";
-function createRunCommand(deps) {
-  const { fs, libFiles, tsconfigPath, runOptions = {}, sharedModules } = deps;
-  return defineCommand3("run", async (args, _ctx) => {
-    let entryPoint = null;
-    let skipTypecheck = runOptions.skipTypecheck ?? false;
-    let timeout = runOptions.timeout ?? 30000;
-    const scriptArgs = [];
-    let collectingArgs = false;
-    for (let i = 0;i < args.length; i++) {
-      const arg = args[i];
-      if (collectingArgs) {
-        scriptArgs.push(arg);
-        continue;
-      }
-      if (arg === "--") {
-        collectingArgs = true;
-      } else if (arg === "--skip-typecheck" || arg === "-s") {
-        skipTypecheck = true;
-      } else if ((arg === "--timeout" || arg === "-t") && args[i + 1]) {
-        timeout = parseInt(args[++i], 10);
-        if (isNaN(timeout))
-          timeout = 30000;
-      } else if (!arg.startsWith("-")) {
-        entryPoint = arg;
-      }
-    }
-    if (!entryPoint) {
-      return {
-        stdout: "",
-        stderr: `Usage: run <entry-point> [options] [-- args...]
-
-Options:
-  --skip-typecheck, -s  Skip type checking
-  --timeout, -t <ms>    Execution timeout (default: 30000)
-
-Example: run /src/index.ts
-`,
-        exitCode: 1
-      };
-    }
-    const logs = [];
-    const originalConsole = {
-      log: console.log,
-      warn: console.warn,
-      error: console.error,
-      info: console.info,
-      debug: console.debug
-    };
-    const formatArgs = (...a) => a.map((v) => typeof v === "object" ? JSON.stringify(v) : String(v)).join(" ");
-    const captureLog = (...a) => {
-      logs.push(formatArgs(...a));
-      originalConsole.log.apply(console, a);
-    };
-    const captureWarn = (...a) => {
-      logs.push(`[warn] ${formatArgs(...a)}`);
-      originalConsole.warn.apply(console, a);
-    };
-    const captureError = (...a) => {
-      logs.push(`[error] ${formatArgs(...a)}`);
-      originalConsole.error.apply(console, a);
-    };
-    const captureInfo = (...a) => {
-      logs.push(`[info] ${formatArgs(...a)}`);
-      originalConsole.info.apply(console, a);
-    };
-    const captureDebug = (...a) => {
-      logs.push(`[debug] ${formatArgs(...a)}`);
-      originalConsole.debug.apply(console, a);
-    };
-    const restoreConsole = () => {
-      console.log = originalConsole.log;
-      console.warn = originalConsole.warn;
-      console.error = originalConsole.error;
-      console.info = originalConsole.info;
-      console.debug = originalConsole.debug;
-    };
-    try {
-      if (!await fs.exists(entryPoint)) {
-        return {
-          stdout: "",
-          stderr: `Error: Entry point not found: ${entryPoint}
-`,
-          exitCode: 1
-        };
-      }
-      if (!skipTypecheck) {
-        const typecheckResult = await typecheck({
-          fs,
-          entryPoint,
-          tsconfigPath,
-          libFiles
-        });
-        if (typecheckResult.hasErrors) {
-          const formatted = formatDiagnosticsForAgent(typecheckResult.diagnostics);
-          return {
-            stdout: "",
-            stderr: `Type errors:
-${formatted}
-`,
-            exitCode: 1
-          };
-        }
-      }
-      const bundleResult = await bundle({
-        fs,
-        entryPoint,
-        format: "esm",
-        sharedModules
-      });
-      console.log = captureLog;
-      console.warn = captureWarn;
-      console.error = captureError;
-      console.info = captureInfo;
-      console.debug = captureDebug;
-      const context = {
-        fs,
-        env: { ...runOptions.env },
-        args: scriptArgs,
-        log: captureLog,
-        error: captureError
-      };
-      const startTime = performance.now();
-      let returnValue;
-      const executeCode = async () => {
-        const module = await loadModule(bundleResult);
-        if (typeof module.main === "function") {
-          returnValue = await module.main(context);
-        }
-      };
-      if (timeout > 0) {
-        const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => reject(new Error(`Execution timed out after ${timeout}ms`)), timeout);
-        });
-        await Promise.race([executeCode(), timeoutPromise]);
-      } else {
-        await executeCode();
-      }
-      const executionTimeMs = performance.now() - startTime;
-      restoreConsole();
-      let output = "";
-      if (logs.length > 0) {
-        output = logs.join(`
-`) + `
-`;
-      }
-      if (returnValue !== undefined) {
-        const returnStr = typeof returnValue === "object" ? JSON.stringify(returnValue, null, 2) : String(returnValue);
-        output += `[return] ${returnStr}
-`;
-      }
-      output += `
-Execution completed in ${executionTimeMs.toFixed(2)}ms
-`;
-      return {
-        stdout: output,
-        stderr: "",
-        exitCode: 0
-      };
-    } catch (err) {
-      restoreConsole();
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      const errorStack = err instanceof Error && err.stack ? `
-${err.stack}` : "";
-      let output = "";
-      if (logs.length > 0) {
-        output = logs.join(`
-`) + `
-
-`;
-      }
-      return {
-        stdout: output,
-        stderr: `Runtime error: ${errorMessage}${errorStack}
-`,
-        exitCode: 1
-      };
-    }
-  });
-}
-// src/commands/index.ts
-function createDefaultCommands(deps) {
-  return [
-    createTscCommand(deps),
-    createBuildCommand(deps),
-    createRunCommand(deps),
-    createInstallCommand(deps),
-    createUninstallCommand(deps),
-    createListCommand(deps)
-  ];
-}
-// src/build-emitter.ts
-class BuildEmitter {
-  listeners = new Set;
-  emit = async (result) => {
-    const promises = [];
-    for (const listener of this.listeners) {
-      const ret = listener(result);
-      if (ret instanceof Promise) {
-        promises.push(ret);
-      }
-    }
-    await Promise.all(promises);
-  };
-  on(callback) {
-    this.listeners.add(callback);
-    return () => {
-      this.listeners.delete(callback);
-    };
-  }
-}
-export {
-  revokeModuleUrl,
-  resolveToEsmUrl,
-  parsePackageSpec,
-  parseLibReferences,
-  parseImportPath,
-  libNameToFileName,
-  hasSharedModuleRegistry,
-  getSharedModuleRuntimeCode,
-  getSharedModuleRegistry,
-  formatEsbuildMessages,
-  fetchLibFile,
-  fetchAllLibs,
-  extractLibName,
-  createModuleUrl,
-  SharedModuleRegistry,
-  LibCache,
-  InMemoryTypesCache,
-  BuildEmitter
-};