@ricsam/quickjs-test-utils 0.0.1 → 1.0.1

package/README.md

@@ -1,45 +1,99 @@
 # @ricsam/quickjs-test-utils
 
-## ⚠️ IMPORTANT NOTICE ⚠️
-
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
-
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
-
-## Purpose
-
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@ricsam/quickjs-test-utils`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
-
-## What is OIDC Trusted Publishing?
-
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
-
-## Setup Instructions
-
-To properly configure OIDC trusted publishing for this package:
-
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
-
-## DO NOT USE THIS PACKAGE
-
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
-
-## More Information
-
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
-
----
-
-**Maintained for OIDC setup purposes only**
+Testing utilities including type checking for QuickJS user code.
+
+```bash
+bun add @ricsam/quickjs-test-utils
+```
+
+#### Type Checking QuickJS Code
+
+Validate TypeScript/JavaScript code that will run inside QuickJS before execution using `ts-morph`:
+
+```typescript
+import { typecheckQuickJSCode } from "@ricsam/quickjs-test-utils";
+
+const result = typecheckQuickJSCode(`
+  serve({
+    fetch(request, server) {
+      const url = new URL(request.url);
+
+      if (url.pathname === "/ws") {
+        server.upgrade(request, { data: { userId: 123 } });
+        return new Response(null, { status: 101 });
+      }
+
+      return Response.json({ message: "Hello!" });
+    },
+    websocket: {
+      message(ws, message) {
+        ws.send("Echo: " + message);
+      }
+    }
+  });
+`, { include: ["core", "fetch"] });
+
+if (!result.success) {
+  console.error("Type errors found:");
+  for (const error of result.errors) {
+    console.error(`  Line ${error.line}: ${error.message}`);
+  }
+}
+```
+
+**Options:**
+
+| Option | Description |
+|--------|-------------|
+| `include` | Which package types to include: `"core"`, `"fetch"`, `"fs"` (default: all) |
+| `compilerOptions` | Additional TypeScript compiler options |
+
+**Using with tests:**
+
+```typescript
+import { describe, expect, test } from "bun:test";
+import { typecheckQuickJSCode } from "@ricsam/quickjs-test-utils";
+
+describe("QuickJS code validation", () => {
+  test("server code is type-safe", () => {
+    const result = typecheckQuickJSCode(userProvidedCode, {
+      include: ["fetch"]
+    });
+    expect(result.success).toBe(true);
+  });
+});
+```
+
+#### Type Definition Strings
+
+The type definitions are also exported as strings for custom use cases:
+
+```typescript
+import {
+  CORE_TYPES,   // ReadableStream, Blob, File, URL, etc.
+  FETCH_TYPES,  // fetch, Request, Response, serve, etc.
+  FS_TYPES,     // fs.getDirectory, FileSystemHandle, etc.
+  TYPE_DEFINITIONS  // All types as { core, fetch, fs }
+} from "@ricsam/quickjs-test-utils";
+
+// Use with your own ts-morph project
+project.createSourceFile("quickjs-globals.d.ts", FETCH_TYPES);
+```
+
+#### Type Definition Files
+
+Each package also exports `.d.ts` files for use with `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "lib": ["ESNext", "DOM"]
+  },
+  "include": ["quickjs-code/**/*.ts"],
+  "references": [
+    { "path": "./node_modules/@ricsam/quickjs-core/src/quickjs.d.ts" },
+    { "path": "./node_modules/@ricsam/quickjs-fetch/src/quickjs.d.ts" },
+    { "path": "./node_modules/@ricsam/quickjs-fs/src/quickjs.d.ts" }
+  ]
+}
+```

package/dist/cjs/context.cjs

@@ -0,0 +1,86 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// packages/test-utils/src/context.ts
+var exports_context = {};
+__export(exports_context, {
+  useTestContext: () => useTestContext,
+  disposeTestContext: () => disposeTestContext,
+  createTestContext: () => createTestContext
+});
+module.exports = __toCommonJS(exports_context);
+var import_quickjs_emscripten = require("quickjs-emscripten");
+var import_quickjs_core = require("@ricsam/quickjs-core");
+async function createTestContext() {
+  const QuickJS = await import_quickjs_emscripten.getQuickJS();
+  const runtime = QuickJS.newRuntime();
+  const context = runtime.newContext();
+  const coreHandle = import_quickjs_core.setupCore(context);
+  import_quickjs_core.clearAllInstanceState();
+  return { runtime, context, coreHandle };
+}
+function disposeTestContext(ctx) {
+  import_quickjs_core.cleanupUnmarshaledHandles(ctx.context);
+  ctx.coreHandle.dispose();
+  ctx.context.dispose();
+  ctx.runtime.dispose();
+}
+function useTestContext() {
+  let ctx;
+  return {
+    async setup() {
+      ctx = await createTestContext();
+      return ctx;
+    },
+    teardown() {
+      if (ctx) {
+        disposeTestContext(ctx);
+        ctx = undefined;
+      }
+    },
+    get context() {
+      if (!ctx)
+        throw new Error("TestContext not initialized. Call setup() first.");
+      return ctx.context;
+    },
+    get runtime() {
+      if (!ctx)
+        throw new Error("TestContext not initialized. Call setup() first.");
+      return ctx.runtime;
+    },
+    get coreHandle() {
+      if (!ctx)
+        throw new Error("TestContext not initialized. Call setup() first.");
+      return ctx.coreHandle;
+    }
+  };
+}
+})
+
+//# debugId=1E24A404C4F7A24364756E2164756E21

package/dist/cjs/context.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/context.ts"],
+  "sourcesContent": [
+    "import {\n  getQuickJS,\n  type QuickJSContext,\n  type QuickJSRuntime,\n} from \"quickjs-emscripten\";\nimport {\n  setupCore,\n  clearAllInstanceState,\n  cleanupUnmarshaledHandles,\n  type CoreHandle,\n} from \"@ricsam/quickjs-core\";\n\nexport interface TestContext {\n  runtime: QuickJSRuntime;\n  context: QuickJSContext;\n  coreHandle: CoreHandle;\n}\n\nexport async function createTestContext(): Promise<TestContext> {\n  const QuickJS = await getQuickJS();\n  const runtime = QuickJS.newRuntime();\n  const context = runtime.newContext();\n  const coreHandle = setupCore(context);\n  clearAllInstanceState();\n\n  return { runtime, context, coreHandle };\n}\n\nexport function disposeTestContext(ctx: TestContext): void {\n  // Clean up duped handles from unmarshal before disposing context\n  cleanupUnmarshaledHandles(ctx.context);\n  ctx.coreHandle.dispose();\n  ctx.context.dispose();\n  ctx.runtime.dispose();\n}\n\n/**\n * Helper for use with beforeEach/afterEach\n *\n * @example\n * const testCtx = useTestContext();\n *\n * beforeEach(async () => {\n *   await testCtx.setup();\n * });\n *\n * afterEach(() => {\n *   testCtx.teardown();\n * });\n *\n * test(\"my test\", () => {\n *   const result = evalCode(testCtx.context, `1 + 1`);\n *   expect(result).toBe(2);\n * });\n */\nexport function useTestContext() {\n  let ctx: TestContext | undefined;\n\n  return {\n    async setup() {\n      ctx = await createTestContext();\n      return ctx;\n    },\n    teardown() {\n      if (ctx) {\n        disposeTestContext(ctx);\n        ctx = undefined;\n      }\n    },\n    get context(): QuickJSContext {\n      if (!ctx) throw new Error(\"TestContext not initialized. Call setup() first.\");\n      return ctx.context;\n    },\n    get runtime(): QuickJSRuntime {\n      if (!ctx) throw new Error(\"TestContext not initialized. Call setup() first.\");\n      return ctx.runtime;\n    },\n    get coreHandle(): CoreHandle {\n      if (!ctx) throw new Error(\"TestContext not initialized. Call setup() first.\");\n      return ctx.coreHandle;\n    },\n  };\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIO,IAJP;AAUO,IALP;AAaA,eAAsB,iBAAiB,GAAyB;AAAA,EAC9D,MAAM,UAAU,MAAM,qCAAW;AAAA,EACjC,MAAM,UAAU,QAAQ,WAAW;AAAA,EACnC,MAAM,UAAU,QAAQ,WAAW;AAAA,EACnC,MAAM,aAAa,8BAAU,OAAO;AAAA,EACpC,0CAAsB;AAAA,EAEtB,OAAO,EAAE,SAAS,SAAS,WAAW;AAAA;AAGjC,SAAS,kBAAkB,CAAC,KAAwB;AAAA,EAEzD,8CAA0B,IAAI,OAAO;AAAA,EACrC,IAAI,WAAW,QAAQ;AAAA,EACvB,IAAI,QAAQ,QAAQ;AAAA,EACpB,IAAI,QAAQ,QAAQ;AAAA;AAsBf,SAAS,cAAc,GAAG;AAAA,EAC/B,IAAI;AAAA,EAEJ,OAAO;AAAA,SACC,MAAK,GAAG;AAAA,MACZ,MAAM,MAAM,kBAAkB;AAAA,MAC9B,OAAO;AAAA;AAAA,IAET,QAAQ,GAAG;AAAA,MACT,IAAI,KAAK;AAAA,QACP,mBAAmB,GAAG;AAAA,QACtB,MAAM;AAAA,MACR;AAAA;AAAA,QAEE,OAAO,GAAmB;AAAA,MAC5B,IAAI,CAAC;AAAA,QAAK,MAAM,IAAI,MAAM,kDAAkD;AAAA,MAC5E,OAAO,IAAI;AAAA;AAAA,QAET,OAAO,GAAmB;AAAA,MAC5B,IAAI,CAAC;AAAA,QAAK,MAAM,IAAI,MAAM,kDAAkD;AAAA,MAC5E,OAAO,IAAI;AAAA;AAAA,QAET,UAAU,GAAe;AAAA,MAC3B,IAAI,CAAC;AAAA,QAAK,MAAM,IAAI,MAAM,kDAAkD;AAAA,MAC5E,OAAO,IAAI;AAAA;AAAA,EAEf;AAAA;",
+  "debugId": "1E24A404C4F7A24364756E2164756E21",
+  "names": []
+}

package/dist/cjs/eval.cjs

@@ -0,0 +1,69 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// packages/test-utils/src/eval.ts
+var exports_eval = {};
+__export(exports_eval, {
+  evalCodeAsync: () => evalCodeAsync,
+  evalCode: () => evalCode
+});
+module.exports = __toCommonJS(exports_eval);
+function evalCode(context, code) {
+  const result = context.evalCode(code);
+  if (result.error) {
+    const err = context.dump(result.error);
+    result.error.dispose();
+    throw new Error(`Eval failed: ${JSON.stringify(err)}`);
+  }
+  const value = context.dump(result.value);
+  result.value.dispose();
+  return value;
+}
+async function evalCodeAsync(context, code) {
+  const result = context.evalCode(code);
+  if (result.error) {
+    const err = context.dump(result.error);
+    result.error.dispose();
+    throw new Error(`Eval failed: ${JSON.stringify(err)}`);
+  }
+  const promiseResult = await context.resolvePromise(result.value);
+  result.value.dispose();
+  context.runtime.executePendingJobs();
+  if (promiseResult.error) {
+    const err = context.dump(promiseResult.error);
+    promiseResult.error.dispose();
+    throw new Error(`Promise rejected: ${JSON.stringify(err)}`);
+  }
+  const value = context.dump(promiseResult.value);
+  promiseResult.value.dispose();
+  return value;
+}
+})
+
+//# debugId=632BB0CC96B641FB64756E2164756E21

package/dist/cjs/eval.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/eval.ts"],
+  "sourcesContent": [
+    "import type { QuickJSContext } from \"quickjs-emscripten\";\n\n/**\n * Evaluate code synchronously and return the result\n *\n * Handles error checking and handle disposal automatically.\n *\n * @example\n * const result = evalCode<number>(context, `1 + 1`);\n * expect(result).toBe(2);\n *\n * @example\n * const obj = evalCode<{ name: string }>(context, `({ name: \"test\" })`);\n * expect(obj.name).toBe(\"test\");\n */\nexport function evalCode<T>(context: QuickJSContext, code: string): T {\n  const result = context.evalCode(code);\n\n  if (result.error) {\n    const err = context.dump(result.error);\n    result.error.dispose();\n    throw new Error(`Eval failed: ${JSON.stringify(err)}`);\n  }\n\n  const value = context.dump(result.value) as T;\n  result.value.dispose();\n  return value;\n}\n\n/**\n * Evaluate async code and return the resolved result\n *\n * Handles promise resolution, error checking, and handle disposal automatically.\n * Also executes pending jobs after resolution.\n *\n * @example\n * const result = await evalCodeAsync<string>(context, `\n *   (async () => {\n *     const blob = new Blob([\"hello\"]);\n *     return await blob.text();\n *   })()\n * `);\n * expect(result).toBe(\"hello\");\n */\nexport async function evalCodeAsync<T>(\n  context: QuickJSContext,\n  code: string\n): Promise<T> {\n  const result = context.evalCode(code);\n\n  if (result.error) {\n    const err = context.dump(result.error);\n    result.error.dispose();\n    throw new Error(`Eval failed: ${JSON.stringify(err)}`);\n  }\n\n  const promiseResult = await context.resolvePromise(result.value);\n  result.value.dispose();\n\n  // Execute any pending jobs\n  context.runtime.executePendingJobs();\n\n  if (promiseResult.error) {\n    const err = context.dump(promiseResult.error);\n    promiseResult.error.dispose();\n    throw new Error(`Promise rejected: ${JSON.stringify(err)}`);\n  }\n\n  const value = context.dump(promiseResult.value) as T;\n  promiseResult.value.dispose();\n  return value;\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeO,SAAS,QAAW,CAAC,SAAyB,MAAiB;AAAA,EACpE,MAAM,SAAS,QAAQ,SAAS,IAAI;AAAA,EAEpC,IAAI,OAAO,OAAO;AAAA,IAChB,MAAM,MAAM,QAAQ,KAAK,OAAO,KAAK;AAAA,IACrC,OAAO,MAAM,QAAQ;AAAA,IACrB,MAAM,IAAI,MAAM,gBAAgB,KAAK,UAAU,GAAG,GAAG;AAAA,EACvD;AAAA,EAEA,MAAM,QAAQ,QAAQ,KAAK,OAAO,KAAK;AAAA,EACvC,OAAO,MAAM,QAAQ;AAAA,EACrB,OAAO;AAAA;AAkBT,eAAsB,aAAgB,CACpC,SACA,MACY;AAAA,EACZ,MAAM,SAAS,QAAQ,SAAS,IAAI;AAAA,EAEpC,IAAI,OAAO,OAAO;AAAA,IAChB,MAAM,MAAM,QAAQ,KAAK,OAAO,KAAK;AAAA,IACrC,OAAO,MAAM,QAAQ;AAAA,IACrB,MAAM,IAAI,MAAM,gBAAgB,KAAK,UAAU,GAAG,GAAG;AAAA,EACvD;AAAA,EAEA,MAAM,gBAAgB,MAAM,QAAQ,eAAe,OAAO,KAAK;AAAA,EAC/D,OAAO,MAAM,QAAQ;AAAA,EAGrB,QAAQ,QAAQ,mBAAmB;AAAA,EAEnC,IAAI,cAAc,OAAO;AAAA,IACvB,MAAM,MAAM,QAAQ,KAAK,cAAc,KAAK;AAAA,IAC5C,cAAc,MAAM,QAAQ;AAAA,IAC5B,MAAM,IAAI,MAAM,qBAAqB,KAAK,UAAU,GAAG,GAAG;AAAA,EAC5D;AAAA,EAEA,MAAM,QAAQ,QAAQ,KAAK,cAAc,KAAK;AAAA,EAC9C,cAAc,MAAM,QAAQ;AAAA,EAC5B,OAAO;AAAA;",
+  "debugId": "632BB0CC96B641FB64756E2164756E21",
+  "names": []
+}

package/dist/cjs/fetch-context.cjs

@@ -0,0 +1,89 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// packages/test-utils/src/fetch-context.ts
+var exports_fetch_context = {};
+__export(exports_fetch_context, {
+  useFetchTestContext: () => useFetchTestContext,
+  disposeFetchTestContext: () => disposeFetchTestContext,
+  createFetchTestContext: () => createFetchTestContext
+});
+module.exports = __toCommonJS(exports_fetch_context);
+var import_quickjs_fetch = require("@ricsam/quickjs-fetch");
+var import_context = require("./context.ts");
+async function createFetchTestContext(options) {
+  const base = await import_context.createTestContext();
+  const fetchHandle = import_quickjs_fetch.setupFetch(base.context, {
+    coreHandle: base.coreHandle,
+    onFetch: options?.onFetch
+  });
+  return { ...base, fetchHandle };
+}
+function disposeFetchTestContext(ctx) {
+  ctx.fetchHandle.dispose();
+  import_context.disposeTestContext(ctx);
+}
+function useFetchTestContext() {
+  let ctx;
+  return {
+    async setup() {
+      ctx = await createFetchTestContext();
+      return ctx;
+    },
+    teardown() {
+      if (ctx) {
+        disposeFetchTestContext(ctx);
+        ctx = undefined;
+      }
+    },
+    get context() {
+      if (!ctx)
+        throw new Error("FetchTestContext not initialized. Call setup() first.");
+      return ctx.context;
+    },
+    get runtime() {
+      if (!ctx)
+        throw new Error("FetchTestContext not initialized. Call setup() first.");
+      return ctx.runtime;
+    },
+    get coreHandle() {
+      if (!ctx)
+        throw new Error("FetchTestContext not initialized. Call setup() first.");
+      return ctx.coreHandle;
+    },
+    get fetchHandle() {
+      if (!ctx)
+        throw new Error("FetchTestContext not initialized. Call setup() first.");
+      return ctx.fetchHandle;
+    }
+  };
+}
+})
+
+//# debugId=63D6126825B82DA964756E2164756E21

package/dist/cjs/fetch-context.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/fetch-context.ts"],
+  "sourcesContent": [
+    "import { setupFetch, type FetchHandle, type SetupFetchOptions } from \"@ricsam/quickjs-fetch\";\nimport {\n  createTestContext,\n  disposeTestContext,\n  type TestContext,\n} from \"./context.ts\";\n\nexport interface FetchTestContext extends TestContext {\n  fetchHandle: FetchHandle;\n}\n\nexport interface CreateFetchTestContextOptions {\n  /** Handler for outbound fetch() calls from QuickJS */\n  onFetch?: SetupFetchOptions[\"onFetch\"];\n}\n\nexport async function createFetchTestContext(\n  options?: CreateFetchTestContextOptions\n): Promise<FetchTestContext> {\n  const base = await createTestContext();\n  const fetchHandle = setupFetch(base.context, {\n    coreHandle: base.coreHandle,\n    onFetch: options?.onFetch,\n  });\n\n  return { ...base, fetchHandle };\n}\n\nexport function disposeFetchTestContext(ctx: FetchTestContext): void {\n  ctx.fetchHandle.dispose();\n  disposeTestContext(ctx);\n}\n\n/**\n * Helper for use with beforeEach/afterEach for fetch tests\n *\n * @example\n * const testCtx = useFetchTestContext();\n *\n * beforeEach(async () => {\n *   await testCtx.setup();\n * });\n *\n * afterEach(() => {\n *   testCtx.teardown();\n * });\n *\n * test(\"headers test\", () => {\n *   const result = evalCode(testCtx.context, `\n *     const headers = new Headers({ \"Content-Type\": \"application/json\" });\n *     headers.get(\"content-type\");\n *   `);\n *   expect(result).toBe(\"application/json\");\n * });\n */\nexport function useFetchTestContext() {\n  let ctx: FetchTestContext | undefined;\n\n  return {\n    async setup() {\n      ctx = await createFetchTestContext();\n      return ctx;\n    },\n    teardown() {\n      if (ctx) {\n        disposeFetchTestContext(ctx);\n        ctx = undefined;\n      }\n    },\n    get context() {\n      if (!ctx) throw new Error(\"FetchTestContext not initialized. Call setup() first.\");\n      return ctx.context;\n    },\n    get runtime() {\n      if (!ctx) throw new Error(\"FetchTestContext not initialized. Call setup() first.\");\n      return ctx.runtime;\n    },\n    get coreHandle() {\n      if (!ctx) throw new Error(\"FetchTestContext not initialized. Call setup() first.\");\n      return ctx.coreHandle;\n    },\n    get fetchHandle() {\n      if (!ctx) throw new Error(\"FetchTestContext not initialized. Call setup() first.\");\n      return ctx.fetchHandle;\n    },\n  };\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAqE,IAArE;AAKO,IAJP;AAeA,eAAsB,sBAAsB,CAC1C,SAC2B;AAAA,EAC3B,MAAM,OAAO,MAAM,iCAAkB;AAAA,EACrC,MAAM,cAAc,gCAAW,KAAK,SAAS;AAAA,IAC3C,YAAY,KAAK;AAAA,IACjB,SAAS,SAAS;AAAA,EACpB,CAAC;AAAA,EAED,OAAO,KAAK,MAAM,YAAY;AAAA;AAGzB,SAAS,uBAAuB,CAAC,KAA6B;AAAA,EACnE,IAAI,YAAY,QAAQ;AAAA,EACxB,kCAAmB,GAAG;AAAA;AAyBjB,SAAS,mBAAmB,GAAG;AAAA,EACpC,IAAI;AAAA,EAEJ,OAAO;AAAA,SACC,MAAK,GAAG;AAAA,MACZ,MAAM,MAAM,uBAAuB;AAAA,MACnC,OAAO;AAAA;AAAA,IAET,QAAQ,GAAG;AAAA,MACT,IAAI,KAAK;AAAA,QACP,wBAAwB,GAAG;AAAA,QAC3B,MAAM;AAAA,MACR;AAAA;AAAA,QAEE,OAAO,GAAG;AAAA,MACZ,IAAI,CAAC;AAAA,QAAK,MAAM,IAAI,MAAM,uDAAuD;AAAA,MACjF,OAAO,IAAI;AAAA;AAAA,QAET,OAAO,GAAG;AAAA,MACZ,IAAI,CAAC;AAAA,QAAK,MAAM,IAAI,MAAM,uDAAuD;AAAA,MACjF,OAAO,IAAI;AAAA;AAAA,QAET,UAAU,GAAG;AAAA,MACf,IAAI,CAAC;AAAA,QAAK,MAAM,IAAI,MAAM,uDAAuD;AAAA,MACjF,OAAO,IAAI;AAAA;AAAA,QAET,WAAW,GAAG;AAAA,MAChB,IAAI,CAAC;AAAA,QAAK,MAAM,IAAI,MAAM,uDAAuD;AAAA,MACjF,OAAO,IAAI;AAAA;AAAA,EAEf;AAAA;",
+  "debugId": "63D6126825B82DA964756E2164756E21",
+  "names": []
+}

package/dist/cjs/fs-context.cjs

@@ -0,0 +1,54 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// packages/test-utils/src/fs-context.ts
+var exports_fs_context = {};
+__export(exports_fs_context, {
+  disposeFsTestContext: () => disposeFsTestContext,
+  createFsTestContext: () => createFsTestContext
+});
+module.exports = __toCommonJS(exports_fs_context);
+var import_quickjs_fs = require("@ricsam/quickjs-fs");
+var import_context = require("./context.ts");
+async function createFsTestContext(options) {
+  const base = await import_context.createTestContext();
+  const memFs = import_quickjs_fs.createMemoryDirectoryHandle(options?.initialFiles);
+  const fsHandle = import_quickjs_fs.setupFs(base.context, {
+    coreHandle: base.coreHandle,
+    getDirectory: async () => memFs
+  });
+  return { ...base, fsHandle, memFs };
+}
+function disposeFsTestContext(ctx) {
+  ctx.fsHandle.dispose();
+  import_context.disposeTestContext(ctx);
+}
+})
+
+//# debugId=1EE240687003E38364756E2164756E21

package/dist/cjs/fs-context.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/fs-context.ts"],
+  "sourcesContent": [
+    "import {\n  setupFs,\n  createMemoryDirectoryHandle,\n  type FsHandle,\n  type HostDirectoryHandle,\n} from \"@ricsam/quickjs-fs\";\nimport {\n  createTestContext,\n  disposeTestContext,\n  type TestContext,\n} from \"./context.ts\";\n\nexport interface FsTestContext extends TestContext {\n  fsHandle: FsHandle;\n  memFs: HostDirectoryHandle;\n}\n\nexport interface CreateFsTestContextOptions {\n  /** Initial files to populate the in-memory filesystem */\n  initialFiles?: Record<string, string | Uint8Array>;\n}\n\nexport async function createFsTestContext(\n  options?: CreateFsTestContextOptions\n): Promise<FsTestContext> {\n  const base = await createTestContext();\n  const memFs = createMemoryDirectoryHandle(options?.initialFiles);\n  const fsHandle = setupFs(base.context, {\n    coreHandle: base.coreHandle,\n    getDirectory: async () => memFs,\n  });\n\n  return { ...base, fsHandle, memFs };\n}\n\nexport function disposeFsTestContext(ctx: FsTestContext): void {\n  ctx.fsHandle.dispose();\n  disposeTestContext(ctx);\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKO,IALP;AAUO,IAJP;AAgBA,eAAsB,mBAAmB,CACvC,SACwB;AAAA,EACxB,MAAM,OAAO,MAAM,iCAAkB;AAAA,EACrC,MAAM,QAAQ,8CAA4B,SAAS,YAAY;AAAA,EAC/D,MAAM,WAAW,0BAAQ,KAAK,SAAS;AAAA,IACrC,YAAY,KAAK;AAAA,IACjB,cAAc,YAAY;AAAA,EAC5B,CAAC;AAAA,EAED,OAAO,KAAK,MAAM,UAAU,MAAM;AAAA;AAG7B,SAAS,oBAAoB,CAAC,KAA0B;AAAA,EAC7D,IAAI,SAAS,QAAQ;AAAA,EACrB,kCAAmB,GAAG;AAAA;",
+  "debugId": "1EE240687003E38364756E2164756E21",
+  "names": []
+}

package/dist/cjs/index.cjs

@@ -0,0 +1,58 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// packages/test-utils/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  useTestContext: () => import_context.useTestContext,
+  useFetchTestContext: () => import_fetch_context.useFetchTestContext,
+  typecheckQuickJSCode: () => import_typecheck.typecheckQuickJSCode,
+  startIntegrationServer: () => import_integration_server.startIntegrationServer,
+  formatTypecheckErrors: () => import_typecheck.formatTypecheckErrors,
+  evalCodeAsync: () => import_eval.evalCodeAsync,
+  evalCode: () => import_eval.evalCode,
+  disposeTestContext: () => import_context.disposeTestContext,
+  disposeFetchTestContext: () => import_fetch_context.disposeFetchTestContext,
+  createTestContext: () => import_context.createTestContext,
+  createFetchTestContext: () => import_fetch_context.createFetchTestContext,
+  TYPE_DEFINITIONS: () => import_quickjs_types.TYPE_DEFINITIONS,
+  FS_TYPES: () => import_quickjs_types.FS_TYPES,
+  FETCH_TYPES: () => import_quickjs_types.FETCH_TYPES,
+  CORE_TYPES: () => import_quickjs_types.CORE_TYPES
+});
+module.exports = __toCommonJS(exports_src);
+var import_context = require("./context.ts");
+var import_fetch_context = require("./fetch-context.ts");
+var import_eval = require("./eval.ts");
+var import_integration_server = require("./integration-server.ts");
+var import_typecheck = require("./typecheck.ts");
+var import_quickjs_types = require("./quickjs-types.ts");
+})
+
+//# debugId=6163F5C604565B7564756E2164756E21

package/dist/cjs/index.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": [
+    "export {\n  createTestContext,\n  disposeTestContext,\n  useTestContext,\n  type TestContext,\n} from \"./context.ts\";\n\nexport {\n  createFetchTestContext,\n  disposeFetchTestContext,\n  useFetchTestContext,\n  type FetchTestContext,\n  type CreateFetchTestContextOptions,\n} from \"./fetch-context.ts\";\n\nexport { evalCode, evalCodeAsync } from \"./eval.ts\";\n\nexport {\n  startIntegrationServer,\n  type IntegrationTestServer,\n  type StartIntegrationServerOptions,\n} from \"./integration-server.ts\";\n\nexport {\n  typecheckQuickJSCode,\n  formatTypecheckErrors,\n  type TypecheckResult,\n  type TypecheckError,\n  type TypecheckOptions,\n} from \"./typecheck.ts\";\n\nexport {\n  CORE_TYPES,\n  FETCH_TYPES,\n  FS_TYPES,\n  TYPE_DEFINITIONS,\n  type TypeDefinitionKey,\n} from \"./quickjs-types.ts\";\n\n// For fs and runtime contexts, import from subpaths:\n// import { createFsTestContext } from \"@ricsam/quickjs-test-utils/fs\";\n// import { createRuntimeTestContext } from \"@ricsam/quickjs-test-utils/runtime\";\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKO,IALP;AAaO,IANP;AAQwC,IAAxC;AAMO,IAJP;AAYO,IANP;AAcO,IANP;",
+  "debugId": "6163F5C604565B7564756E2164756E21",
+  "names": []
+}