@ricsam/isolate 0.0.1 → 0.1.1

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

@@ -0,0 +1,2 @@
+import type { ModuleResolver } from "../types.ts";
+export declare function createModuleResolver(): ModuleResolver;

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

@@ -0,0 +1,6 @@
+import type { MutableRuntimeDiagnostics } from "../bridge/diagnostics.ts";
+import { type RemoteRuntime } from "../internal/client/index.ts";
+import type { ScriptRuntime } from "../types.ts";
+export declare function createScriptRuntimeAdapter(runtime: RemoteRuntime, diagnostics: MutableRuntimeDiagnostics, options?: {
+    onBeforeDispose?: (reason?: string) => void;
+}): ScriptRuntime;

package/dist/types/server/app-server.d.ts

@@ -0,0 +1,3 @@
+import type { DaemonConnection } from "../internal/client/index.ts";
+import type { AppServer, CreateAppServerOptions } from "../types.ts";
+export declare function createAppServerAdapter(getConnection: () => Promise<DaemonConnection>, options: CreateAppServerOptions): Promise<AppServer>;

package/dist/types/testing/integration-helpers.d.ts

@@ -0,0 +1,9 @@
+import type { IsolateHost, RequestResult } from "../types.ts";
+export declare function createTestId(label: string): string;
+export declare function createTestHost(label: string): Promise<{
+    host: IsolateHost;
+    socketPath: string;
+    cleanup: () => Promise<void>;
+}>;
+export declare function expectResponse(result: RequestResult): Response;
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, label: string): Promise<T>;

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

@@ -0,0 +1,8 @@
+import { formatTypecheckErrors as formatLegacyTypecheckErrors } from "../internal/typecheck/index.ts";
+import type { TypeCapability, TypeProfile, TypeProfileName, TypecheckRequest } from "../types.ts";
+export declare function getTypeProfile(input?: {
+    profile?: TypeProfileName;
+    capabilities?: TypeCapability[];
+}): TypeProfile;
+export declare function typecheck(request: TypecheckRequest): import("../internal/typecheck/typecheck.ts").TypecheckResult;
+export declare const formatTypecheckErrors: typeof formatLegacyTypecheckErrors;

package/dist/types/types.d.ts

@@ -0,0 +1,233 @@
+import type { ConsoleEntry as LegacyConsoleEntry, PlaywrightEvent as LegacyPlaywrightEvent, RunResults as LegacyRunResults, TestEvent as LegacyTestEvent } from "./internal/client/index.ts";
+export type ConsoleEntry = LegacyConsoleEntry;
+export type RunResults = LegacyRunResults;
+export type TestEvent = LegacyTestEvent;
+export type PlaywrightEvent = LegacyPlaywrightEvent;
+export interface HostCallContext {
+    signal: AbortSignal;
+    runtimeId: string;
+    requestId?: string;
+    resourceId: string;
+    metadata: Record<string, string>;
+}
+export interface ModuleImporter {
+    path: string;
+    resolveDir: string;
+}
+export interface ModuleSource {
+    code: string;
+    filename: string;
+    resolveDir: string;
+    static?: boolean;
+}
+export type ModuleResolveResult = string | ModuleSource | null | undefined | Promise<string | ModuleSource | null | undefined>;
+export type ModuleResolverSourceLoader = (relativePath: string, context: HostCallContext) => ModuleResolveResult;
+export type ModuleResolverFallback = (specifier: string, importer: ModuleImporter, context: HostCallContext) => ModuleResolveResult;
+export interface ModuleResolver {
+    mountNodeModules(virtualMount: string, hostPath: string): ModuleResolver;
+    virtual(specifier: string, source: ModuleResolveResult | (() => ModuleResolveResult), options?: Partial<ModuleSource>): ModuleResolver;
+    virtualFile(specifier: string, filePath: string, options?: Partial<ModuleSource>): ModuleResolver;
+    sourceTree(prefix: string, loader: ModuleResolverSourceLoader): ModuleResolver;
+    fallback(loader: ModuleResolverFallback): ModuleResolver;
+    resolve(specifier: string, importer: ModuleImporter, context: HostCallContext): Promise<ModuleSource>;
+}
+export interface FileBindings {
+    readFile?: (path: string, context: HostCallContext) => Promise<ArrayBuffer>;
+    writeFile?: (path: string, data: ArrayBuffer, context: HostCallContext) => Promise<void>;
+    unlink?: (path: string, context: HostCallContext) => Promise<void>;
+    readdir?: (path: string, context: HostCallContext) => Promise<string[]>;
+    mkdir?: (path: string, options: {
+        recursive?: boolean;
+    } | undefined, context: HostCallContext) => Promise<void>;
+    rmdir?: (path: string, context: HostCallContext) => Promise<void>;
+    stat?: (path: string, context: HostCallContext) => Promise<{
+        isFile: boolean;
+        isDirectory: boolean;
+        size: number;
+    }>;
+    rename?: (from: string, to: string, context: HostCallContext) => Promise<void>;
+}
+export type ToolHandler = (...args: [...unknown[], HostCallContext]) => unknown | Promise<unknown> | AsyncGenerator<unknown, unknown, unknown>;
+export type ToolBindings = Record<string, ToolHandler>;
+export interface HostBindings {
+    console?: {
+        onEntry?: (entry: ConsoleEntry, context: HostCallContext) => void;
+    };
+    fetch?: (request: Request, context: HostCallContext) => Response | Promise<Response>;
+    files?: FileBindings;
+    modules?: ModuleResolver;
+    tools?: ToolBindings;
+}
+export interface RuntimeDiagnostics {
+    activeRequests: number;
+    activeResources: number;
+    pendingFiles: number;
+    pendingFetches: number;
+    pendingModules: number;
+    pendingTools: number;
+    streamCount: number;
+    lastError?: string;
+    reused?: boolean;
+    lifecycleState: "idle" | "active" | "reloading" | "disposing";
+}
+export interface BrowserRuntimeDiagnostics extends RuntimeDiagnostics {
+    browserConsoleLogs: number;
+    networkRequests: number;
+    networkResponses: number;
+    pageErrors: number;
+    requestFailures: number;
+    collectedData: {
+        browserConsoleLogs: unknown[];
+        pageErrors: unknown[];
+        networkRequests: unknown[];
+        networkResponses: unknown[];
+        requestFailures: unknown[];
+    };
+}
+export interface WebSocketUpgradeData {
+    connectionId: string;
+    requested?: boolean;
+    [key: string]: unknown;
+}
+export type RequestResult = {
+    type: "response";
+    response: Response;
+} | {
+    type: "websocket";
+    upgradeData: WebSocketUpgradeData;
+};
+export interface AppServer {
+    handle(request: Request, options?: {
+        requestId?: string;
+        signal?: AbortSignal;
+        metadata?: Record<string, string>;
+    }): Promise<RequestResult>;
+    ws: {
+        open(connectionId: string): Promise<void>;
+        message(connectionId: string, data: string | ArrayBuffer): Promise<void>;
+        close(connectionId: string, code: number, reason: string): Promise<void>;
+        error(connectionId: string, error: Error): Promise<void>;
+    };
+    reload(reason?: string): Promise<void>;
+    dispose(options?: {
+        hard?: boolean;
+        reason?: string;
+    }): Promise<void>;
+    diagnostics(): Promise<RuntimeDiagnostics>;
+}
+export interface ScriptRuntime {
+    eval(code: string, options?: string | {
+        filename?: string;
+        executionTimeout?: number;
+    }): Promise<void>;
+    dispose(options?: {
+        hard?: boolean;
+        reason?: string;
+    }): Promise<void>;
+    diagnostics(): Promise<RuntimeDiagnostics>;
+    events: {
+        on(event: string, handler: (payload: unknown) => void): () => void;
+        emit(event: string, payload: unknown): Promise<void>;
+    };
+    tests: {
+        run(options?: {
+            timeoutMs?: number;
+        }): Promise<RunResults>;
+        hasTests(): Promise<boolean>;
+        reset(): Promise<void>;
+    };
+}
+export interface BrowserRuntime {
+    run(code: string, options?: {
+        filename?: string;
+        asTestSuite?: boolean;
+        timeoutMs?: number;
+    }): Promise<{
+        tests?: RunResults;
+        value?: unknown;
+    }>;
+    diagnostics(): Promise<BrowserRuntimeDiagnostics>;
+    dispose(options?: {
+        hard?: boolean;
+        reason?: string;
+    }): Promise<void>;
+}
+export interface CreateRuntimeOptions {
+    key?: string;
+    bindings: HostBindings;
+    features?: {
+        tests?: boolean;
+    };
+    cwd?: string;
+    executionTimeout?: number;
+    memoryLimitMB?: number;
+}
+export interface CreateAppServerOptions extends CreateRuntimeOptions {
+    key: string;
+    entry: string;
+    entryFilename?: string;
+    webSockets?: {
+        onCommand?: (command: {
+            type: "message" | "close";
+            connectionId: string;
+            data?: string | ArrayBuffer;
+            code?: number;
+            reason?: string;
+        }) => void;
+    };
+}
+export interface CreateBrowserRuntimeOptions extends CreateRuntimeOptions {
+    browser: {
+        page: any;
+        readFile?: (normalizedVirtualPath: string) => Promise<Buffer>;
+        captureConsole?: boolean;
+        writeFile?: (normalizedVirtualPath: string, data: Buffer) => Promise<void> | void;
+        createPage?: (context: any) => Promise<any> | any;
+        createContext?: (options?: any) => Promise<any> | any;
+        onEvent?: (event: PlaywrightEvent) => void;
+    };
+}
+export interface IsolateHost {
+    createAppServer(options: CreateAppServerOptions): Promise<AppServer>;
+    createRuntime(options: CreateRuntimeOptions): Promise<ScriptRuntime>;
+    createBrowserRuntime(options: CreateBrowserRuntimeOptions): Promise<BrowserRuntime>;
+    diagnostics(): Promise<{
+        runtimes: number;
+        servers: number;
+        connected: boolean;
+    }>;
+    close(): Promise<void>;
+}
+export interface CreateIsolateHostOptions {
+    engine?: "auto";
+    daemon?: {
+        socketPath?: string;
+        entrypoint?: string;
+        cwd?: string;
+        timeoutMs?: number;
+        autoStart?: boolean;
+    };
+}
+export type TypeProfileName = "backend" | "agent" | "browser-test";
+export type TypeCapability = "fetch" | "files" | "tests" | "browser" | "tools" | "console" | "encoding" | "timers";
+export interface TypeProfile {
+    profile: TypeProfileName;
+    capabilities: TypeCapability[];
+    include: Array<"core" | "fetch" | "fs" | "console" | "encoding" | "timers" | "testEnvironment" | "playwright">;
+    files: Array<{
+        name: string;
+        content: string;
+    }>;
+}
+export interface TypecheckRequest {
+    code: string;
+    profile?: TypeProfileName;
+    capabilities?: TypeCapability[];
+    libraryTypes?: Record<string, {
+        files: Array<{
+            path: string;
+            content: string;
+        }>;
+    }>;
+    compilerOptions?: Record<string, unknown>;
+}

package/package.json

@@ -1,10 +1,86 @@
 {
   "name": "@ricsam/isolate",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @ricsam/isolate",
+  "version": "0.1.1",
+  "type": "module",
+  "description": "Unified runtime host for app servers, script runtimes, browser runtimes, module resolution, file bindings, and typechecking",
+  "author": "ricsam <oss@ricsam.dev>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ricsam/isolate.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ricsam/isolate/issues"
+  },
+  "homepage": "https://github.com/ricsam/isolate#readme",
   "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
+    "isolated-vm",
+    "sandbox",
+    "javascript",
+    "runtime",
+    "fetch",
+    "filesystem",
+    "streams",
+    "v8",
+    "isolate"
+  ],
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/mjs/index.mjs",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/cjs/index.cjs",
+      "import": "./dist/mjs/index.mjs"
+    },
+    "./daemon": {
+      "types": "./dist/types/daemon.d.ts",
+      "require": "./dist/cjs/daemon.cjs",
+      "import": "./dist/mjs/daemon.mjs"
+    }
+  },
+  "bin": {
+    "isolate-daemon": "./dist/cjs/daemon.cjs"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bun scripts/build.ts",
+    "build:npm": "bun scripts/build.ts",
+    "test": "node --test --experimental-strip-types 'src/**/*.test.ts' --test-reporter tap --test-reporter-destination stdout",
+    "test:spec": "node --test --experimental-strip-types 'src/**/*.test.ts' --test-reporter spec --test-reporter-destination stdout",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@msgpack/msgpack": "^3.1.2",
+    "@rollup/plugin-commonjs": "^28.0.0",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.0",
+    "@rollup/plugin-replace": "^6.0.0",
+    "@types/mime-types": "3.0.1",
+    "linkedom": "^0.18.12",
+    "mime-types": "^3.0.2",
+    "rollup": "^4.0.0",
+    "ts-morph": "^24.0.0"
+  },
+  "devDependencies": {
+    "@changesets/cli": "latest",
+    "@types/node": "^24",
+    "playwright": "^1",
+    "typescript": "^5"
+  },
+  "peerDependencies": {
+    "isolated-vm": "^6",
+    "playwright": "^1"
+  },
+  "peerDependenciesMeta": {
+    "playwright": {
+      "optional": true
+    }
+  }
 }