sandlot 0.1.0

package/dist/internal.js

@@ -0,0 +1,1897 @@
+// 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`;
+var DB_NAME = "ts-lib-cache";
+var DB_VERSION = 1;
+var STORE_NAME = "libs";
+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;
+}
+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}`;
+}
+
+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 (missing.length === 0) {
+        return cached;
+      }
+      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);
+    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));
+  }
+  async clear() {
+    const tx = this.db.transaction(STORE_NAME, "readwrite");
+    const store = tx.objectStore(STORE_NAME);
+    await promisifyRequest(store.clear());
+  }
+  close() {
+    this.db.close();
+  }
+}
+async function fetchAndCacheLibs(libs = getDefaultBrowserLibs()) {
+  const cache = await LibCache.create();
+  try {
+    return await cache.getOrFetch(libs);
+  } finally {
+    cache.close();
+  }
+}
+// src/shared-modules.ts
+var GLOBAL_KEY = "__sandlot_shared_modules__";
+
+class SharedModuleRegistry {
+  modules = new Map;
+  constructor() {
+    globalThis[GLOBAL_KEY] = this;
+  }
+  register(moduleId, module) {
+    this.modules.set(moduleId, module);
+    return this;
+  }
+  registerAll(modules) {
+    for (const [id, mod] of Object.entries(modules)) {
+      this.modules.set(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()];
+  }
+  clear() {
+    this.modules.clear();
+  }
+  get size() {
+    return this.modules.size;
+  }
+}
+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 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.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
+import * as esbuild from "esbuild-wasm";
+var initialized = false;
+var initPromise = null;
+function getWasmUrl() {
+  const version = "0.27.2";
+  return `https://unpkg.com/esbuild-wasm@${version}/esbuild.wasm`;
+}
+async function initBundler() {
+  if (initialized)
+    return;
+  if (initPromise) {
+    await initPromise;
+    return;
+  }
+  initPromise = esbuild.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(build2) {
+      build2.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}` }] };
+      });
+      build2.onLoad({ filter: /.*/, namespace: "sandlot-shared" }, (args) => {
+        const contents = `export default ${getSharedModuleRuntimeCode(args.path)};
+export * from ${JSON.stringify(args.path)};
+// Re-export all named exports by importing from registry
+const __mod__ = ${getSharedModuleRuntimeCode(args.path)};
+for (const __k__ in __mod__) {
+  if (__k__ !== 'default') Object.defineProperty(exports, __k__, { 
+    enumerable: true, 
+    get: function() { return __mod__[__k__]; } 
+  });
+}`;
+        const esmContents = `
+const __sandlot_mod__ = ${getSharedModuleRuntimeCode(args.path)};
+export default __sandlot_mod__.default ?? __sandlot_mod__;
+${generateNamedExports(args.path)}
+`;
+        return {
+          contents: esmContents.trim(),
+          loader: "js"
+        };
+      });
+      build2.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 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(`
+`);
+}
+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 result = await esbuild.build({
+    entryPoints: [normalizedEntry],
+    bundle: true,
+    write: false,
+    format,
+    minify,
+    sourcemap: sourcemap ? "inline" : false,
+    globalName,
+    target,
+    external,
+    plugins: [plugin]
+  });
+  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.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(`
+`);
+}
+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, 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
+      });
+      if (onBuild) {
+        await onBuild(bundleResult);
+      }
+      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)
+`;
+      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
+      };
+    }
+  });
+}
+function createInstallCommand(deps) {
+  const { fs, typesCache } = deps;
+  return defineCommand("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 defineCommand("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 defineCommand("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
+      };
+    }
+  });
+}
+function createRunCommand(deps) {
+  const { fs, libFiles, tsconfigPath, runOptions = {}, sharedModules } = deps;
+  return defineCommand("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
+      };
+    }
+  });
+}
+function createDefaultCommands(deps) {
+  return [
+    createTscCommand(deps),
+    createBuildCommand(deps),
+    createRunCommand(deps),
+    createInstallCommand(deps),
+    createUninstallCommand(deps),
+    createListCommand(deps)
+  ];
+}
+export {
+  revokeModuleUrl,
+  resolveToEsmUrl,
+  parsePackageSpec,
+  parseLibReferences,
+  parseImportPath,
+  libNameToFileName,
+  hasSharedModuleRegistry,
+  getSharedModuleRuntimeCode,
+  getSharedModuleRegistry,
+  formatEsbuildMessages,
+  fetchLibFile,
+  fetchAllLibs,
+  extractLibName,
+  createModuleUrl,
+  SharedModuleRegistry,
+  LibCache,
+  InMemoryTypesCache
+};