@ricsam/isolate 0.0.1 → 0.1.0

package/dist/mjs/server/app-server.mjs

@@ -0,0 +1,118 @@
+// packages/isolate/src/server/app-server.ts
+import { IsolateServer } from "../internal/server/index.mjs";
+import { createRuntimeDiagnostics } from "../bridge/diagnostics.mjs";
+import { createRuntimeBindingsAdapter } from "../bridge/runtime-bindings.mjs";
+import { withRequestContext } from "../bridge/request-context.mjs";
+async function createAppServerAdapter(getConnection, options) {
+  const diagnostics = createRuntimeDiagnostics();
+  const server = new IsolateServer({
+    namespaceId: options.key,
+    getConnection
+  });
+  let runtimeId = options.key;
+  const bindingsAdapter = createRuntimeBindingsAdapter(options.bindings, () => runtimeId, diagnostics);
+  await server.start({
+    entry: options.entry,
+    entryFilename: options.entryFilename,
+    runtimeOptions: {
+      ...bindingsAdapter.runtimeOptions,
+      cwd: options.cwd,
+      memoryLimitMB: options.memoryLimitMB,
+      executionTimeout: options.executionTimeout,
+      testEnvironment: options.features?.tests ?? false
+    },
+    onWebSocketCommand: (command) => {
+      options.webSockets?.onCommand?.(command);
+    }
+  });
+  runtimeId = server.getRuntime()?.id ?? options.key;
+  async function handleRequest(request, handleOptions) {
+    diagnostics.activeRequests += 1;
+    diagnostics.lifecycleState = "active";
+    try {
+      return await withRequestContext({
+        requestId: handleOptions?.requestId,
+        metadata: handleOptions?.metadata,
+        signal: handleOptions?.signal ?? request.signal
+      }, async () => {
+        const response = await server.fetch.dispatchRequest(request, {
+          signal: handleOptions?.signal,
+          requestId: handleOptions?.requestId,
+          metadata: handleOptions?.metadata
+        });
+        const upgradeRequest = await server.fetch.getUpgradeRequest();
+        if (upgradeRequest?.requested) {
+          return {
+            type: "websocket",
+            upgradeData: {
+              requested: upgradeRequest.requested,
+              connectionId: upgradeRequest.connectionId
+            }
+          };
+        }
+        return {
+          type: "response",
+          response
+        };
+      });
+    } catch (error) {
+      diagnostics.lastError = error instanceof Error ? error.message : String(error);
+      throw error;
+    } finally {
+      diagnostics.activeRequests -= 1;
+      diagnostics.lifecycleState = "idle";
+    }
+  }
+  return {
+    handle: handleRequest,
+    ws: {
+      open: async (connectionId) => {
+        await server.fetch.dispatchWebSocketOpen(connectionId);
+      },
+      message: async (connectionId, data) => {
+        await server.fetch.dispatchWebSocketMessage(connectionId, data);
+      },
+      close: async (connectionId, code, reason) => {
+        await server.fetch.dispatchWebSocketClose(connectionId, code, reason);
+      },
+      error: async (connectionId, error) => {
+        await server.fetch.dispatchWebSocketError(connectionId, error);
+      }
+    },
+    reload: async () => {
+      diagnostics.lifecycleState = "reloading";
+      try {
+        bindingsAdapter.reset("AppServer.reload()");
+        await server.reload();
+        runtimeId = server.getRuntime()?.id ?? options.key;
+      } finally {
+        diagnostics.lifecycleState = "idle";
+      }
+    },
+    dispose: async (disposeOptions) => {
+      diagnostics.lifecycleState = "disposing";
+      try {
+        if (disposeOptions?.hard) {
+          bindingsAdapter.reset(disposeOptions?.reason ?? "AppServer.dispose(hard)");
+          await server.reload();
+          bindingsAdapter.abort(disposeOptions?.reason ?? "AppServer.dispose(hard)");
+          await server.close();
+          return;
+        }
+        bindingsAdapter.abort(disposeOptions?.reason ?? "AppServer.dispose()");
+        await server.close();
+      } finally {
+        diagnostics.lifecycleState = "idle";
+      }
+    },
+    diagnostics: async () => ({
+      ...diagnostics,
+      reused: server.getRuntime()?.reused
+    })
+  };
+}
+export {
+  createAppServerAdapter
+};
+
+//# debugId=35EE9B7D9A1E94D564756E2164756E21

package/dist/mjs/server/app-server.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/server/app-server.ts"],
+  "sourcesContent": [
+    "import { IsolateServer } from \"../internal/server/index.mjs\";\nimport type { DaemonConnection } from \"../internal/client/index.mjs\";\nimport { createRuntimeDiagnostics } from \"../bridge/diagnostics.mjs\";\nimport { createRuntimeBindingsAdapter } from \"../bridge/runtime-bindings.mjs\";\nimport { withRequestContext } from \"../bridge/request-context.mjs\";\nimport type { AppServer, CreateAppServerOptions, RequestResult } from \"../types.mjs\";\n\nexport async function createAppServerAdapter(\n  getConnection: () => Promise<DaemonConnection>,\n  options: CreateAppServerOptions,\n): Promise<AppServer> {\n  const diagnostics = createRuntimeDiagnostics();\n  const server = new IsolateServer({\n    namespaceId: options.key,\n    getConnection,\n  });\n\n  let runtimeId = options.key;\n  const bindingsAdapter = createRuntimeBindingsAdapter(\n    options.bindings,\n    () => runtimeId,\n    diagnostics,\n  );\n  await server.start({\n    entry: options.entry,\n    entryFilename: options.entryFilename,\n    runtimeOptions: {\n      ...bindingsAdapter.runtimeOptions,\n      cwd: options.cwd,\n      memoryLimitMB: options.memoryLimitMB,\n      executionTimeout: options.executionTimeout,\n      testEnvironment: options.features?.tests ?? false,\n    },\n    onWebSocketCommand: (command) => {\n      options.webSockets?.onCommand?.(command);\n    },\n  });\n  runtimeId = server.getRuntime()?.id ?? options.key;\n\n  async function handleRequest(request: Request, handleOptions?: { requestId?: string; signal?: AbortSignal; metadata?: Record<string, string> }): Promise<RequestResult> {\n    diagnostics.activeRequests += 1;\n    diagnostics.lifecycleState = \"active\";\n    try {\n      return await withRequestContext(\n        {\n          requestId: handleOptions?.requestId,\n          metadata: handleOptions?.metadata,\n          signal: handleOptions?.signal ?? request.signal,\n        },\n        async () => {\n          const response = await server.fetch.dispatchRequest(request, {\n            signal: handleOptions?.signal,\n            requestId: handleOptions?.requestId,\n            metadata: handleOptions?.metadata,\n          });\n          const upgradeRequest = await server.fetch.getUpgradeRequest();\n          if (upgradeRequest?.requested) {\n            return {\n              type: \"websocket\",\n              upgradeData: {\n                requested: upgradeRequest.requested,\n                connectionId: upgradeRequest.connectionId,\n              },\n            };\n          }\n\n          return {\n            type: \"response\",\n            response,\n          };\n        },\n      );\n    } catch (error) {\n      diagnostics.lastError = error instanceof Error ? error.message : String(error);\n      throw error;\n    } finally {\n      diagnostics.activeRequests -= 1;\n      diagnostics.lifecycleState = \"idle\";\n    }\n  }\n\n  return {\n    handle: handleRequest,\n    ws: {\n      open: async (connectionId) => {\n        await server.fetch.dispatchWebSocketOpen(connectionId);\n      },\n      message: async (connectionId, data) => {\n        await server.fetch.dispatchWebSocketMessage(connectionId, data);\n      },\n      close: async (connectionId, code, reason) => {\n        await server.fetch.dispatchWebSocketClose(connectionId, code, reason);\n      },\n      error: async (connectionId, error) => {\n        await server.fetch.dispatchWebSocketError(connectionId, error);\n      },\n    },\n    reload: async () => {\n      diagnostics.lifecycleState = \"reloading\";\n      try {\n        bindingsAdapter.reset(\"AppServer.reload()\");\n        await server.reload();\n        runtimeId = server.getRuntime()?.id ?? options.key;\n      } finally {\n        diagnostics.lifecycleState = \"idle\";\n      }\n    },\n    dispose: async (disposeOptions) => {\n      diagnostics.lifecycleState = \"disposing\";\n      try {\n        if (disposeOptions?.hard) {\n          bindingsAdapter.reset(disposeOptions?.reason ?? \"AppServer.dispose(hard)\");\n          await server.reload();\n          bindingsAdapter.abort(disposeOptions?.reason ?? \"AppServer.dispose(hard)\");\n          await server.close();\n          return;\n        }\n        bindingsAdapter.abort(disposeOptions?.reason ?? \"AppServer.dispose()\");\n        await server.close();\n      } finally {\n        diagnostics.lifecycleState = \"idle\";\n      }\n    },\n    diagnostics: async () => ({\n      ...diagnostics,\n      reused: server.getRuntime()?.reused,\n    }),\n  };\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "35EE9B7D9A1E94D564756E2164756E21",
+  "names": []
+}

package/dist/mjs/testing/integration-helpers.mjs

@@ -0,0 +1,63 @@
+// packages/isolate/src/testing/integration-helpers.ts
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { createIsolateHost } from "../index.mjs";
+function sanitizeLabel(label) {
+  return label.replace(/[^a-z0-9_-]+/gi, "-").toLowerCase();
+}
+function createTestId(label) {
+  return `${sanitizeLabel(label)}-${process.pid}-${randomUUID()}`;
+}
+function createTestSocketPath(label) {
+  const suffix = randomUUID().slice(0, 8);
+  return path.join("/tmp", `isolate-${sanitizeLabel(label)}-${suffix}.sock`);
+}
+async function createTestHost(label) {
+  const socketPath = createTestSocketPath(label);
+  await fs.rm(socketPath, { force: true });
+  const host = await createIsolateHost({
+    daemon: {
+      socketPath,
+      timeoutMs: 15000
+    }
+  });
+  return {
+    host,
+    socketPath,
+    cleanup: async () => {
+      await host.close().catch(() => {});
+      await fs.rm(socketPath, { force: true }).catch(() => {});
+    }
+  };
+}
+function expectResponse(result) {
+  if (result.type !== "response") {
+    assert.fail(`Expected a response result, received ${result.type}`);
+  }
+  return result.response;
+}
+async function withTimeout(promise, timeoutMs, label) {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new Error(`Timed out after ${timeoutMs}ms: ${label}`));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timeoutId !== undefined) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+export {
+  withTimeout,
+  expectResponse,
+  createTestId,
+  createTestHost
+};
+
+//# debugId=1BDD75435E03F45E64756E2164756E21

package/dist/mjs/testing/integration-helpers.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/testing/integration-helpers.ts"],
+  "sourcesContent": [
+    "import assert from \"node:assert/strict\";\nimport fs from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { randomUUID } from \"node:crypto\";\nimport { createIsolateHost } from \"../index.mjs\";\nimport type { IsolateHost, RequestResult } from \"../types.mjs\";\n\nfunction sanitizeLabel(label: string): string {\n  return label.replace(/[^a-z0-9_-]+/gi, \"-\").toLowerCase();\n}\n\nexport function createTestId(label: string): string {\n  return `${sanitizeLabel(label)}-${process.pid}-${randomUUID()}`;\n}\n\nfunction createTestSocketPath(label: string): string {\n  const suffix = randomUUID().slice(0, 8);\n  return path.join(\"/tmp\", `isolate-${sanitizeLabel(label)}-${suffix}.sock`);\n}\n\nexport async function createTestHost(\n  label: string,\n): Promise<{\n  host: IsolateHost;\n  socketPath: string;\n  cleanup: () => Promise<void>;\n}> {\n  const socketPath = createTestSocketPath(label);\n  await fs.rm(socketPath, { force: true });\n\n  const host = await createIsolateHost({\n    daemon: {\n      socketPath,\n      timeoutMs: 15_000,\n    },\n  });\n\n  return {\n    host,\n    socketPath,\n    cleanup: async () => {\n      await host.close().catch(() => {});\n      await fs.rm(socketPath, { force: true }).catch(() => {});\n    },\n  };\n}\n\nexport function expectResponse(result: RequestResult): Response {\n  if (result.type !== \"response\") {\n    assert.fail(`Expected a response result, received ${result.type}`);\n  }\n  return result.response;\n}\n\nexport async function withTimeout<T>(\n  promise: Promise<T>,\n  timeoutMs: number,\n  label: string,\n): Promise<T> {\n  let timeoutId: ReturnType<typeof setTimeout> | undefined;\n  const timeoutPromise = new Promise<T>((_, reject) => {\n    timeoutId = setTimeout(() => {\n      reject(new Error(`Timed out after ${timeoutMs}ms: ${label}`));\n    }, timeoutMs);\n  });\n\n  try {\n    return await Promise.race([promise, timeoutPromise]);\n  } finally {\n    if (timeoutId !== undefined) {\n      clearTimeout(timeoutId);\n    }\n  }\n}\n"
+  ],
+  "mappings": ";AAAA;AACA;AACA;AACA;AACA;AAGA,SAAS,aAAa,CAAC,OAAuB;AAAA,EAC5C,OAAO,MAAM,QAAQ,kBAAkB,GAAG,EAAE,YAAY;AAAA;AAGnD,SAAS,YAAY,CAAC,OAAuB;AAAA,EAClD,OAAO,GAAG,cAAc,KAAK,KAAK,QAAQ,OAAO,WAAW;AAAA;AAG9D,SAAS,oBAAoB,CAAC,OAAuB;AAAA,EACnD,MAAM,SAAS,WAAW,EAAE,MAAM,GAAG,CAAC;AAAA,EACtC,OAAO,KAAK,KAAK,QAAQ,WAAW,cAAc,KAAK,KAAK,aAAa;AAAA;AAG3E,eAAsB,cAAc,CAClC,OAKC;AAAA,EACD,MAAM,aAAa,qBAAqB,KAAK;AAAA,EAC7C,MAAM,GAAG,GAAG,YAAY,EAAE,OAAO,KAAK,CAAC;AAAA,EAEvC,MAAM,OAAO,MAAM,kBAAkB;AAAA,IACnC,QAAQ;AAAA,MACN;AAAA,MACA,WAAW;AAAA,IACb;AAAA,EACF,CAAC;AAAA,EAED,OAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,SAAS,YAAY;AAAA,MACnB,MAAM,KAAK,MAAM,EAAE,MAAM,MAAM,EAAE;AAAA,MACjC,MAAM,GAAG,GAAG,YAAY,EAAE,OAAO,KAAK,CAAC,EAAE,MAAM,MAAM,EAAE;AAAA;AAAA,EAE3D;AAAA;AAGK,SAAS,cAAc,CAAC,QAAiC;AAAA,EAC9D,IAAI,OAAO,SAAS,YAAY;AAAA,IAC9B,OAAO,KAAK,wCAAwC,OAAO,MAAM;AAAA,EACnE;AAAA,EACA,OAAO,OAAO;AAAA;AAGhB,eAAsB,WAAc,CAClC,SACA,WACA,OACY;AAAA,EACZ,IAAI;AAAA,EACJ,MAAM,iBAAiB,IAAI,QAAW,CAAC,GAAG,WAAW;AAAA,IACnD,YAAY,WAAW,MAAM;AAAA,MAC3B,OAAO,IAAI,MAAM,mBAAmB,gBAAgB,OAAO,CAAC;AAAA,OAC3D,SAAS;AAAA,GACb;AAAA,EAED,IAAI;AAAA,IACF,OAAO,MAAM,QAAQ,KAAK,CAAC,SAAS,cAAc,CAAC;AAAA,YACnD;AAAA,IACA,IAAI,cAAc,WAAW;AAAA,MAC3B,aAAa,SAAS;AAAA,IACxB;AAAA;AAAA;",
+  "debugId": "1BDD75435E03F45E64756E2164756E21",
+  "names": []
+}

package/dist/mjs/typecheck/index.mjs

@@ -0,0 +1,56 @@
+// packages/isolate/src/typecheck/index.ts
+import { TYPE_DEFINITIONS, formatTypecheckErrors as formatLegacyTypecheckErrors, typecheckIsolateCode } from "../internal/typecheck/index.mjs";
+var CAPABILITY_MAP = {
+  fetch: ["fetch"],
+  files: ["fs"],
+  tests: ["testEnvironment"],
+  browser: ["playwright"],
+  tools: [],
+  console: ["console"],
+  encoding: ["encoding"],
+  timers: ["timers"]
+};
+var PROFILE_DEFAULTS = {
+  backend: ["console", "encoding", "fetch", "files", "timers"],
+  agent: ["console", "encoding", "fetch", "files", "timers"],
+  "browser-test": ["console", "encoding", "fetch", "tests", "browser", "timers"]
+};
+function unique(values) {
+  return [...new Set(values)];
+}
+function getTypeProfile(input) {
+  const profile = input?.profile ?? "backend";
+  const capabilities = unique([...PROFILE_DEFAULTS[profile] ?? PROFILE_DEFAULTS.backend, ...input?.capabilities ?? []]);
+  const include = unique([
+    "core",
+    ...capabilities.flatMap((capability) => CAPABILITY_MAP[capability])
+  ]);
+  return {
+    profile,
+    capabilities,
+    include,
+    files: include.map((key) => ({
+      name: `isolate-${key}.d.ts`,
+      content: TYPE_DEFINITIONS[key]
+    })).filter((entry) => Boolean(entry.content))
+  };
+}
+function typecheck(request) {
+  const profile = getTypeProfile({
+    profile: request.profile,
+    capabilities: request.capabilities
+  });
+  return typecheckIsolateCode(request.code, {
+    include: profile.include,
+    libraryTypes: request.libraryTypes,
+    compilerOptions: request.compilerOptions
+  });
+}
+var formatTypecheckErrors = formatLegacyTypecheckErrors;
+export {
+  typecheck,
+  getTypeProfile,
+  formatTypecheckErrors
+};
+
+//# debugId=F61B6EBA06E30ECD64756E2164756E21

package/dist/mjs/typecheck/index.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/typecheck/index.ts"],
+  "sourcesContent": [
+    "import { TYPE_DEFINITIONS, formatTypecheckErrors as formatLegacyTypecheckErrors, typecheckIsolateCode } from \"../internal/typecheck/index.mjs\";\nimport type { TypeCapability, TypeProfile, TypeProfileName, TypecheckRequest } from \"../types.mjs\";\n\ntype IncludedType = \"core\" | \"fetch\" | \"fs\" | \"console\" | \"encoding\" | \"timers\" | \"testEnvironment\" | \"playwright\";\n\nconst CAPABILITY_MAP: Record<TypeCapability, IncludedType[]> = {\n  fetch: [\"fetch\"],\n  files: [\"fs\"],\n  tests: [\"testEnvironment\"],\n  browser: [\"playwright\"],\n  tools: [],\n  console: [\"console\"],\n  encoding: [\"encoding\"],\n  timers: [\"timers\"],\n};\n\nconst PROFILE_DEFAULTS: Record<TypeProfileName, TypeCapability[]> = {\n  backend: [\"console\", \"encoding\", \"fetch\", \"files\", \"timers\"],\n  agent: [\"console\", \"encoding\", \"fetch\", \"files\", \"timers\"],\n  \"browser-test\": [\"console\", \"encoding\", \"fetch\", \"tests\", \"browser\", \"timers\"],\n};\n\nfunction unique<T>(values: T[]): T[] {\n  return [...new Set(values)];\n}\n\nexport function getTypeProfile(input?: {\n  profile?: TypeProfileName;\n  capabilities?: TypeCapability[];\n}): TypeProfile {\n  const profile = input?.profile ?? \"backend\";\n  const capabilities = unique([...(PROFILE_DEFAULTS[profile] ?? PROFILE_DEFAULTS.backend), ...(input?.capabilities ?? [])]);\n  const include: IncludedType[] = unique([\n    \"core\",\n    ...capabilities.flatMap((capability) => CAPABILITY_MAP[capability]),\n  ]) as IncludedType[];\n\n  return {\n    profile,\n    capabilities,\n    include,\n    files: include\n      .map((key) => ({\n        name: `isolate-${key}.d.ts`,\n        content: TYPE_DEFINITIONS[key as keyof typeof TYPE_DEFINITIONS],\n      }))\n      .filter((entry) => Boolean(entry.content)) as Array<{ name: string; content: string }>,\n  };\n}\n\nexport function typecheck(request: TypecheckRequest) {\n  const profile = getTypeProfile({\n    profile: request.profile,\n    capabilities: request.capabilities,\n  });\n\n  return typecheckIsolateCode(request.code, {\n    include: profile.include,\n    libraryTypes: request.libraryTypes,\n    compilerOptions: request.compilerOptions as never,\n  });\n}\n\nexport const formatTypecheckErrors = formatLegacyTypecheckErrors;\n"
+  ],
+  "mappings": ";AAAA,oDAA2B;AAK3B,IAAM,iBAAyD;AAAA,EAC7D,OAAO,CAAC,OAAO;AAAA,EACf,OAAO,CAAC,IAAI;AAAA,EACZ,OAAO,CAAC,iBAAiB;AAAA,EACzB,SAAS,CAAC,YAAY;AAAA,EACtB,OAAO,CAAC;AAAA,EACR,SAAS,CAAC,SAAS;AAAA,EACnB,UAAU,CAAC,UAAU;AAAA,EACrB,QAAQ,CAAC,QAAQ;AACnB;AAEA,IAAM,mBAA8D;AAAA,EAClE,SAAS,CAAC,WAAW,YAAY,SAAS,SAAS,QAAQ;AAAA,EAC3D,OAAO,CAAC,WAAW,YAAY,SAAS,SAAS,QAAQ;AAAA,EACzD,gBAAgB,CAAC,WAAW,YAAY,SAAS,SAAS,WAAW,QAAQ;AAC/E;AAEA,SAAS,MAAS,CAAC,QAAkB;AAAA,EACnC,OAAO,CAAC,GAAG,IAAI,IAAI,MAAM,CAAC;AAAA;AAGrB,SAAS,cAAc,CAAC,OAGf;AAAA,EACd,MAAM,UAAU,OAAO,WAAW;AAAA,EAClC,MAAM,eAAe,OAAO,CAAC,GAAI,iBAAiB,YAAY,iBAAiB,SAAU,GAAI,OAAO,gBAAgB,CAAC,CAAE,CAAC;AAAA,EACxH,MAAM,UAA0B,OAAO;AAAA,IACrC;AAAA,IACA,GAAG,aAAa,QAAQ,CAAC,eAAe,eAAe,WAAW;AAAA,EACpE,CAAC;AAAA,EAED,OAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,OAAO,QACJ,IAAI,CAAC,SAAS;AAAA,MACb,MAAM,WAAW;AAAA,MACjB,SAAS,iBAAiB;AAAA,IAC5B,EAAE,EACD,OAAO,CAAC,UAAU,QAAQ,MAAM,OAAO,CAAC;AAAA,EAC7C;AAAA;AAGK,SAAS,SAAS,CAAC,SAA2B;AAAA,EACnD,MAAM,UAAU,eAAe;AAAA,IAC7B,SAAS,QAAQ;AAAA,IACjB,cAAc,QAAQ;AAAA,EACxB,CAAC;AAAA,EAED,OAAO,qBAAqB,QAAQ,MAAM;AAAA,IACxC,SAAS,QAAQ;AAAA,IACjB,cAAc,QAAQ;AAAA,IACtB,iBAAiB,QAAQ;AAAA,EAC3B,CAAC;AAAA;AAGI,IAAM,wBAAwB;",
+  "debugId": "F61B6EBA06E30ECD64756E2164756E21",
+  "names": []
+}

package/dist/mjs/types.mjs

@@ -0,0 +1,2 @@
+
+//# debugId=857F9FAECA46A67964756E2164756E21

package/dist/mjs/types.mjs.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "857F9FAECA46A67964756E2164756E21",
+  "names": []
+}

package/dist/types/bridge/diagnostics.d.ts

@@ -0,0 +1,12 @@
+import type { RuntimeDiagnostics } from "../types.ts";
+export interface MutableRuntimeDiagnostics extends RuntimeDiagnostics {
+    activeRequests: number;
+    activeResources: number;
+    pendingFiles: number;
+    pendingFetches: number;
+    pendingModules: number;
+    pendingTools: number;
+    streamCount: number;
+    lifecycleState: "idle" | "active" | "reloading" | "disposing";
+}
+export declare function createRuntimeDiagnostics(): MutableRuntimeDiagnostics;

package/dist/types/bridge/legacy-adapters.d.ts

@@ -0,0 +1,14 @@
+import type { RuntimeOptions } from "../internal/client/index.ts";
+import type { ModuleLoaderCallback } from "../internal/protocol/index.ts";
+import type { HostBindings, HostCallContext, ModuleResolveResult, ModuleResolver, ModuleSource } from "../types.ts";
+import type { MutableRuntimeDiagnostics } from "./diagnostics.ts";
+export declare function createLegacyRuntimeOptions(bindings: HostBindings, getRuntimeId: () => string, diagnostics: MutableRuntimeDiagnostics): RuntimeOptions;
+export declare function createMappedNodeModulesLoader(mappings: Array<{
+    from: string;
+    to: string;
+}>): ModuleLoaderCallback | undefined;
+export declare function tryResolveModule(resolver: ModuleResolver | undefined, specifier: string, importer: {
+    path: string;
+    resolveDir: string;
+}, context: HostCallContext): Promise<ModuleSource | null>;
+export declare function normalizeExplicitModuleResult(specifier: string, result: ModuleResolveResult, fallbackResolveDir?: string): Promise<ModuleSource | null>;

package/dist/types/bridge/request-context.d.ts

@@ -0,0 +1,10 @@
+export declare function withRequestContext<T>(context: {
+    requestId?: string;
+    metadata?: Record<string, string>;
+    signal?: AbortSignal;
+}, fn: () => Promise<T>): Promise<T>;
+export declare function getRequestContext(): {
+    requestId?: string;
+    metadata: Record<string, string>;
+    signal?: AbortSignal;
+};

package/dist/types/bridge/runtime-bindings.d.ts

@@ -0,0 +1,14 @@
+import type { RuntimeOptions } from "../internal/client/index.ts";
+import type { HostBindings, HostCallContext, ModuleResolveResult, ModuleResolver, ModuleSource } from "../types.ts";
+import type { MutableRuntimeDiagnostics } from "./diagnostics.ts";
+export interface RuntimeBindingsAdapter {
+    runtimeOptions: RuntimeOptions;
+    abort(reason?: unknown): void;
+    reset(reason?: unknown): void;
+}
+export declare function createRuntimeBindingsAdapter(bindings: HostBindings, getRuntimeId: () => string, diagnostics: MutableRuntimeDiagnostics): RuntimeBindingsAdapter;
+export declare function tryResolveModule(resolver: ModuleResolver | undefined, specifier: string, importer: {
+    path: string;
+    resolveDir: string;
+}, context: HostCallContext): Promise<ModuleSource | null>;
+export declare function normalizeExplicitModuleResult(specifier: string, result: ModuleResolveResult, fallbackResolveDir?: string): Promise<ModuleSource | null>;

package/dist/types/browser/browser-runtime.d.ts

@@ -0,0 +1,3 @@
+import type { RemoteRuntime, RuntimeOptions } from "../internal/client/index.ts";
+import type { BrowserRuntime, CreateBrowserRuntimeOptions } from "../types.ts";
+export declare function createBrowserRuntimeAdapter(createRuntime: (options: RuntimeOptions) => Promise<RemoteRuntime>, options: CreateBrowserRuntimeOptions): Promise<BrowserRuntime>;

package/dist/types/daemon.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/types/files/index.d.ts

@@ -0,0 +1,5 @@
+import type { FileBindings } from "../types.ts";
+export declare function createFileBindings(options: {
+    root: string;
+    allowWrite?: boolean;
+}): FileBindings;

package/dist/types/host/create-isolate-host.d.ts

@@ -0,0 +1,2 @@
+import type { CreateIsolateHostOptions, IsolateHost } from "../types.ts";
+export declare function createIsolateHost(options?: CreateIsolateHostOptions): Promise<IsolateHost>;

package/dist/types/host/index.d.ts

@@ -0,0 +1 @@
+export { createIsolateHost } from "./create-isolate-host.ts";

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export { createIsolateHost } from "./host/index.ts";
+export { createModuleResolver } from "./modules/index.ts";
+export { createFileBindings } from "./files/index.ts";
+export { getTypeProfile, typecheck, formatTypecheckErrors } from "./typecheck/index.ts";
+export type { AppServer, BrowserRuntime, BrowserRuntimeDiagnostics, ConsoleEntry, CreateAppServerOptions, CreateBrowserRuntimeOptions, CreateIsolateHostOptions, CreateRuntimeOptions, FileBindings, HostBindings, HostCallContext, IsolateHost, ModuleImporter, ModuleResolveResult, ModuleResolver, ModuleResolverFallback, ModuleResolverSourceLoader, ModuleSource, PlaywrightEvent, RequestResult, RunResults, ScriptRuntime, TestEvent, ToolBindings, ToolHandler, RuntimeDiagnostics, TypeCapability, TypeProfile, TypeProfileName, TypecheckRequest, WebSocketUpgradeData, } from "./types.ts";

package/dist/types/internal/client/connection.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Connection handling for the isolate client.
+ */
+import type { ConnectOptions, DaemonConnection } from "./types.ts";
+/**
+ * Connect to the isolate daemon.
+ */
+export declare function connect(options?: ConnectOptions): Promise<DaemonConnection>;
+export declare function isBenignDisposeError(error: unknown): boolean;

package/dist/types/internal/client/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ./index.ts
+ *
+ * Client library for connecting to the isolate daemon.
+ * Works with Bun, Node.js, and other JavaScript runtimes.
+ */
+export { connect, isBenignDisposeError } from "./connection.ts";
+export type { ConnectOptions, DaemonConnection, Namespace, RuntimeOptions, RemoteRuntime, RemoteFetchHandle, RemoteTimersHandle, RemoteConsoleHandle, RemoteTestEnvironmentHandle, RemotePlaywrightHandle, DisposeRuntimeOptions, DispatchOptions, ConsoleCallbacks, FetchCallback, FileSystemCallbacks, PlaywrightOptions, PlaywrightEvent, TestEnvironmentOptions, RunResults, TestResult, TestInfo, TestError, TestEvent, SuiteInfo, SuiteResult, CollectedData, ConsoleEntry, CustomFunctions, UpgradeRequest, WebSocketCommand, } from "./types.ts";

package/dist/types/internal/client/types.d.ts

@@ -0,0 +1,198 @@
+/**
+ * Types for the isolate client.
+ */
+import type { RunTestsResult, TestResult as ProtocolTestResult, TestInfo as ProtocolTestInfo, TestError as ProtocolTestError, TestEvent as ProtocolTestEvent, SuiteInfo as ProtocolSuiteInfo, SuiteResult as ProtocolSuiteResult, CollectedData as ProtocolCollectedData, ConsoleEntry as ProtocolConsoleEntry, PlaywrightEvent as ProtocolPlaywrightEvent, CustomFunctionType, EvalOptions as ProtocolEvalOptions, TestEnvironmentOptions as ProtocolTestEnvironmentOptions, PlaywrightOptions as ProtocolPlaywrightOptions, BaseRuntimeOptions, ConsoleCallbacks, FetchCallback, WebSocketCallback, FileSystemCallbacks, ModuleLoaderCallback, ModuleLoaderResult, CustomFunction, CustomAsyncGeneratorFunction, CustomFunctionDefinition, CustomFunctions, DispatchOptions } from "../protocol/index.ts";
+export type RunResults = RunTestsResult;
+export type TestResult = ProtocolTestResult;
+export type TestInfo = ProtocolTestInfo;
+export type TestError = ProtocolTestError;
+export type TestEvent = ProtocolTestEvent;
+export type SuiteInfo = ProtocolSuiteInfo;
+export type SuiteResult = ProtocolSuiteResult;
+export type CollectedData = ProtocolCollectedData;
+export type ConsoleEntry = ProtocolConsoleEntry;
+export type PlaywrightEvent = ProtocolPlaywrightEvent;
+export type EvalOptions = ProtocolEvalOptions;
+export type TestEnvironmentOptions = ProtocolTestEnvironmentOptions;
+export type PlaywrightOptions = ProtocolPlaywrightOptions;
+export type { ConsoleCallbacks, FetchCallback, WebSocketCallback, FileSystemCallbacks, ModuleLoaderCallback, ModuleLoaderResult, CustomFunction, CustomAsyncGeneratorFunction, CustomFunctionDefinition, CustomFunctions, CustomFunctionType, DispatchOptions, };
+/**
+ * Options for connecting to the daemon.
+ */
+export interface ConnectOptions {
+    /** Unix socket path */
+    socket?: string;
+    /** TCP host */
+    host?: string;
+    /** TCP port */
+    port?: number;
+    /** Connection timeout in ms */
+    timeout?: number;
+}
+/**
+ * Namespace for runtime pooling/reuse.
+ * Runtimes created in a namespace are cached on dispose and can be reused.
+ */
+export interface Namespace {
+    /** The namespace ID */
+    readonly id: string;
+    /** Create a runtime in this namespace (cacheable on dispose) */
+    createRuntime(options?: RuntimeOptions): Promise<RemoteRuntime>;
+}
+/**
+ * Connection to the daemon.
+ */
+export interface DaemonConnection {
+    /** Create a new runtime in the daemon */
+    createRuntime(options?: RuntimeOptions): Promise<RemoteRuntime>;
+    /** Create a namespace for runtime pooling/reuse */
+    createNamespace(id: string): Namespace;
+    /** Close the connection */
+    close(): Promise<void>;
+    /** Check if connected */
+    isConnected(): boolean;
+}
+/**
+ * Options for creating a runtime.
+ * Extends BaseRuntimeOptions and adds client-specific fs type.
+ */
+export interface RuntimeOptions<T extends Record<string, any[]> = Record<string, unknown[]>> extends BaseRuntimeOptions<T> {
+    /** File system callback handlers */
+    fs?: FileSystemCallbacks;
+    /** Register callback for WebSocket commands from isolate at runtime creation time */
+    onWebSocketCommand?: (cmd: WebSocketCommand) => void;
+}
+/**
+ * WebSocket upgrade request info.
+ */
+export interface UpgradeRequest {
+    requested: true;
+    connectionId: string;
+}
+/**
+ * WebSocket command from isolate.
+ */
+export interface WebSocketCommand {
+    type: "message" | "close";
+    connectionId: string;
+    data?: string | ArrayBuffer;
+    code?: number;
+    reason?: string;
+}
+/**
+ * Remote fetch handle - provides access to fetch/serve operations.
+ * All methods are async since they communicate over IPC.
+ */
+export interface RemoteFetchHandle {
+    /** Dispatch HTTP request to serve() handler */
+    dispatchRequest(request: Request, options?: DispatchOptions): Promise<Response>;
+    /** Check if isolate requested WebSocket upgrade */
+    getUpgradeRequest(): Promise<UpgradeRequest | null>;
+    /** Dispatch WebSocket open event to isolate */
+    dispatchWebSocketOpen(connectionId: string): Promise<void>;
+    /** Dispatch WebSocket message event to isolate */
+    dispatchWebSocketMessage(connectionId: string, message: string | ArrayBuffer): Promise<void>;
+    /** Dispatch WebSocket close event to isolate */
+    dispatchWebSocketClose(connectionId: string, code: number, reason: string): Promise<void>;
+    /** Dispatch WebSocket error event to isolate */
+    dispatchWebSocketError(connectionId: string, error: Error): Promise<void>;
+    /** Register callback for WebSocket commands from isolate */
+    onWebSocketCommand(callback: (cmd: WebSocketCommand) => void): () => void;
+    /** Check if serve() has been called */
+    hasServeHandler(): Promise<boolean>;
+    /** Check if there are active WebSocket connections */
+    hasActiveConnections(): Promise<boolean>;
+}
+/**
+ * Remote timers handle - provides access to timer operations.
+ * Timers fire automatically based on real time.
+ * All methods are async since they communicate over IPC.
+ */
+export interface RemoteTimersHandle {
+    /** Clear all pending timers */
+    clearAll(): Promise<void>;
+}
+/**
+ * Remote console handle - provides access to console state.
+ * All methods are async since they communicate over IPC.
+ */
+export interface RemoteConsoleHandle {
+    /** Reset all console state (timers, counters, group depth) */
+    reset(): Promise<void>;
+    /** Get console.time() timers */
+    getTimers(): Promise<Map<string, number>>;
+    /** Get console.count() counters */
+    getCounters(): Promise<Map<string, number>>;
+    /** Get current console.group() nesting depth */
+    getGroupDepth(): Promise<number>;
+}
+export interface DisposeRuntimeOptions {
+    /** Permanently delete the runtime instead of allowing namespaced reuse. */
+    hard?: boolean;
+    /** Optional caller-supplied reason for disposal, used for diagnostics/logging. */
+    reason?: string;
+}
+/**
+ * Remote runtime handle.
+ */
+export interface RemoteRuntime {
+    /** Unique runtime identifier */
+    readonly id: string;
+    /** True if runtime was reused from namespace pool */
+    readonly reused?: boolean;
+    /** Fetch handle - access to fetch/serve operations */
+    readonly fetch: RemoteFetchHandle;
+    /** Timers handle - access to timer operations */
+    readonly timers: RemoteTimersHandle;
+    /** Console handle - access to console state */
+    readonly console: RemoteConsoleHandle;
+    /** Test environment handle (methods throw if not enabled) */
+    readonly testEnvironment: RemoteTestEnvironmentHandle;
+    /** Playwright handle (methods throw if not configured) */
+    readonly playwright: RemotePlaywrightHandle;
+    /**
+     * Execute code as ES module in the isolate.
+     * Supports top-level await.
+     * @param code - The code to execute
+     * @param filenameOrOptions - Optional filename or eval options
+     */
+    eval(code: string, filenameOrOptions?: string | EvalOptions): Promise<void>;
+    /**
+     * Listen for events emitted from isolate code (via __emit).
+     * @param event - The event name to listen for
+     * @param callback - Called when the event is received
+     * @returns Unsubscribe function
+     */
+    on(event: string, callback: (payload: unknown) => void): () => void;
+    /**
+     * Emit an event to the isolate (received via __on in isolate code).
+     * @param event - The event name
+     * @param payload - The event payload (must be JSON-serializable)
+     */
+    emit(event: string, payload: unknown): void;
+    /** Dispose the runtime */
+    dispose(options?: DisposeRuntimeOptions): Promise<void>;
+}
+/**
+ * Remote test environment handle.
+ * All methods are async since they communicate over IPC.
+ */
+export interface RemoteTestEnvironmentHandle {
+    /** Run all registered tests and return results */
+    runTests(timeout?: number): Promise<RunResults>;
+    /** Check if any tests are registered */
+    hasTests(): Promise<boolean>;
+    /** Get count of registered tests */
+    getTestCount(): Promise<number>;
+    /** Reset test environment state */
+    reset(): Promise<void>;
+}
+/**
+ * Remote playwright handle - provides access to browser data collection.
+ */
+export interface RemotePlaywrightHandle {
+    /** Get collected browser console logs and network data */
+    getCollectedData(): CollectedData;
+    /** Clear collected data */
+    clearCollectedData(): void;
+}