@ricsam/quickjs-core 0.0.1 → 0.2.0

package/README.md

@@ -1,45 +1,38 @@
 # @ricsam/quickjs-core
 
-## ⚠️ 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-core`
-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**
+Core utilities and Web Streams API.
+
+```typescript
+import { setupCore } from "@ricsam/quickjs-core";
+
+const handle = setupCore(context);
+```
+
+**Injected Globals:**
+- `ReadableStream`, `WritableStream`, `TransformStream`
+- `ReadableStreamDefaultReader`, `WritableStreamDefaultWriter`
+- `Blob`, `File`
+
+**Usage in QuickJS:**
+
+```javascript
+// Streams
+const stream = new ReadableStream({
+  start(controller) {
+    controller.enqueue("chunk1");
+    controller.enqueue("chunk2");
+    controller.close();
+  }
+});
+
+const reader = stream.getReader();
+const { value, done } = await reader.read();
+
+// Blob
+const blob = new Blob(["hello", " ", "world"], { type: "text/plain" });
+const text = await blob.text(); // "hello world"
+
+// File
+const file = new File(["content"], "file.txt", { type: "text/plain" });
+console.log(file.name); // "file.txt"
+```

package/dist/cjs/index.cjs

@@ -0,0 +1,143 @@
+// @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/core/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  withScopeAsync: () => import_scope.withScopeAsync,
+  withScope: () => import_scope.withScope,
+  unmarshal: () => import_unmarshal.unmarshal,
+  setupCore: () => setupCore,
+  setState: () => import_class_builder2.setState,
+  setInstanceState: () => import_class_builder2.setInstanceState,
+  marshal: () => import_marshal.marshal,
+  isHandle: () => import_marshal.isHandle,
+  getState: () => import_class_builder2.getState,
+  getInstanceStateById: () => import_class_builder2.getInstanceStateById,
+  getInstanceState: () => import_class_builder2.getInstanceState,
+  getHandleType: () => import_marshal.getHandleType,
+  defineFunction: () => import_function_builder.defineFunction,
+  defineClass: () => import_class_builder2.defineClass,
+  defineAsyncFunction: () => import_function_builder.defineAsyncFunction,
+  createWritableStream: () => import_writable_stream2.createWritableStream,
+  createURLSearchParamsClass: () => import_url_search_params2.createURLSearchParamsClass,
+  createURLClass: () => import_url2.createURLClass,
+  createStateMap: () => import_class_builder2.createStateMap,
+  createReadableStream: () => import_readable_stream2.createReadableStream,
+  createFile: () => import_file2.createFile,
+  createBlob: () => import_blob2.createBlob,
+  consumeReadableStream: () => import_readable_stream2.consumeReadableStream,
+  clearAllInstanceState: () => import_class_builder2.clearAllInstanceState,
+  cleanupUnmarshaledHandles: () => import_unmarshal.cleanupUnmarshaledHandles,
+  cleanupInstanceState: () => import_class_builder2.cleanupInstanceState,
+  addURLSearchParamsGetter: () => import_url2.addURLSearchParamsGetter,
+  INTERNAL_STATE: () => import_types.INTERNAL_STATE
+});
+module.exports = __toCommonJS(exports_src);
+var import_class_builder = require("./class-builder.ts");
+var import_readable_stream = require("./streams/readable-stream.ts");
+var import_writable_stream = require("./streams/writable-stream.ts");
+var import_transform_stream = require("./streams/transform-stream.ts");
+var import_blob = require("./blob.ts");
+var import_file = require("./file.ts");
+var import_dom_exception = require("./dom-exception.ts");
+var import_url_search_params = require("./url-search-params.ts");
+var import_url = require("./url.ts");
+var import_types = require("./types.ts");
+var import_scope = require("./scope.ts");
+var import_marshal = require("./marshal.ts");
+var import_unmarshal = require("./unmarshal.ts");
+var import_function_builder = require("./function-builder.ts");
+var import_class_builder2 = require("./class-builder.ts");
+var import_readable_stream2 = require("./streams/readable-stream.ts");
+var import_writable_stream2 = require("./streams/writable-stream.ts");
+var import_blob2 = require("./blob.ts");
+var import_file2 = require("./file.ts");
+var import_url_search_params2 = require("./url-search-params.ts");
+var import_url2 = require("./url.ts");
+function setupCore(context, options) {
+  const stateMap = options?.stateMap ?? import_class_builder.createStateMap();
+  const handles = [];
+  const ReadableStreamDefaultReader = import_readable_stream.createReadableStreamDefaultReaderClass(context, stateMap);
+  context.setProp(context.global, "ReadableStreamDefaultReader", ReadableStreamDefaultReader);
+  ReadableStreamDefaultReader.dispose();
+  const readerClassRef = context.getProp(context.global, "ReadableStreamDefaultReader");
+  const ReadableStream = import_readable_stream.createReadableStreamClass(context, stateMap, readerClassRef);
+  readerClassRef.dispose();
+  context.setProp(context.global, "ReadableStream", ReadableStream);
+  ReadableStream.dispose();
+  const WritableStreamDefaultWriter = import_writable_stream.createWritableStreamDefaultWriterClass(context, stateMap);
+  context.setProp(context.global, "WritableStreamDefaultWriter", WritableStreamDefaultWriter);
+  WritableStreamDefaultWriter.dispose();
+  const writerClassRef = context.getProp(context.global, "WritableStreamDefaultWriter");
+  const WritableStream = import_writable_stream.createWritableStreamClass(context, stateMap, writerClassRef);
+  writerClassRef.dispose();
+  context.setProp(context.global, "WritableStream", WritableStream);
+  WritableStream.dispose();
+  const TransformStream = import_transform_stream.createTransformStreamClass(context, stateMap);
+  context.setProp(context.global, "TransformStream", TransformStream);
+  TransformStream.dispose();
+  const BlobClass = import_blob.createBlobClass(context, stateMap, (source) => import_readable_stream.createReadableStream(context, stateMap, source));
+  context.setProp(context.global, "Blob", BlobClass);
+  BlobClass.dispose();
+  const blobClassRef = context.getProp(context.global, "Blob");
+  const FileClass = import_file.createFileClass(context, stateMap, blobClassRef);
+  blobClassRef.dispose();
+  context.setProp(context.global, "File", FileClass);
+  FileClass.dispose();
+  const DOMExceptionClass = import_dom_exception.createDOMExceptionClass(context, stateMap);
+  context.setProp(context.global, "DOMException", DOMExceptionClass);
+  DOMExceptionClass.dispose();
+  const URLSearchParamsClass = import_url_search_params.createURLSearchParamsClass(context, stateMap);
+  context.setProp(context.global, "URLSearchParams", URLSearchParamsClass);
+  URLSearchParamsClass.dispose();
+  const urlSearchParamsIteratorResult = context.evalCode(`
+    URLSearchParams.prototype[Symbol.iterator] = function() {
+      return this.entries()[Symbol.iterator]();
+    };
+  `);
+  if (urlSearchParamsIteratorResult.error) {
+    urlSearchParamsIteratorResult.error.dispose();
+  } else {
+    urlSearchParamsIteratorResult.value.dispose();
+  }
+  const URLClass = import_url.createURLClass(context, stateMap);
+  context.setProp(context.global, "URL", URLClass);
+  URLClass.dispose();
+  import_url.addURLSearchParamsGetter(context);
+  return {
+    stateMap,
+    dispose() {
+      handles.length = 0;
+    }
+  };
+}
+})
+
+//# debugId=FE2DEE7125C06AA764756E2164756E21

package/dist/cjs/index.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": [
+    "import type { QuickJSContext, QuickJSHandle } from \"quickjs-emscripten\";\nimport type { SetupCoreOptions, CoreHandle, StateMap } from \"./types.ts\";\nimport { createStateMap } from \"./class-builder.ts\";\nimport {\n  createReadableStreamClass,\n  createReadableStreamDefaultReaderClass,\n  createReadableStream,\n} from \"./streams/readable-stream.ts\";\nimport {\n  createWritableStreamClass,\n  createWritableStreamDefaultWriterClass,\n} from \"./streams/writable-stream.ts\";\nimport { createTransformStreamClass } from \"./streams/transform-stream.ts\";\nimport { createBlobClass } from \"./blob.ts\";\nimport { createFileClass } from \"./file.ts\";\nimport { createDOMExceptionClass } from \"./dom-exception.ts\";\nimport { createURLSearchParamsClass } from \"./url-search-params.ts\";\nimport { createURLClass, addURLSearchParamsGetter } from \"./url.ts\";\n\n/**\n * Setup core APIs in a QuickJS context\n *\n * Injects the following globals:\n * - ReadableStream, WritableStream, TransformStream\n * - ReadableStreamDefaultReader, WritableStreamDefaultWriter\n * - Blob\n * - File\n * - DOMException\n * - URL, URLSearchParams\n *\n * @example\n * const handle = setupCore(context);\n *\n * context.evalCode(`\n *   const blob = new Blob([\"hello\", \" \", \"world\"], { type: \"text/plain\" });\n *   const text = await blob.text(); // \"hello world\"\n *\n *   const stream = new ReadableStream({\n *     start(controller) {\n *       controller.enqueue(\"chunk1\");\n *       controller.enqueue(\"chunk2\");\n *       controller.close();\n *     }\n *   });\n * `);\n */\nexport function setupCore(\n  context: QuickJSContext,\n  options?: SetupCoreOptions\n): CoreHandle {\n  const stateMap = options?.stateMap ?? createStateMap();\n  const handles: { name: string; handle: QuickJSHandle }[] = [];\n\n  // Create ReadableStreamDefaultReader class first\n  const ReadableStreamDefaultReader = createReadableStreamDefaultReaderClass(\n    context,\n    stateMap\n  );\n  context.setProp(\n    context.global,\n    \"ReadableStreamDefaultReader\",\n    ReadableStreamDefaultReader\n  );\n  ReadableStreamDefaultReader.dispose();\n\n  // Create ReadableStream class\n  const readerClassRef = context.getProp(context.global, \"ReadableStreamDefaultReader\");\n  const ReadableStream = createReadableStreamClass(\n    context,\n    stateMap,\n    readerClassRef\n  );\n  readerClassRef.dispose();\n  context.setProp(context.global, \"ReadableStream\", ReadableStream);\n  ReadableStream.dispose();\n\n  // Create WritableStreamDefaultWriter class first\n  const WritableStreamDefaultWriter = createWritableStreamDefaultWriterClass(\n    context,\n    stateMap\n  );\n  context.setProp(\n    context.global,\n    \"WritableStreamDefaultWriter\",\n    WritableStreamDefaultWriter\n  );\n  WritableStreamDefaultWriter.dispose();\n\n  // Create WritableStream class\n  const writerClassRef = context.getProp(context.global, \"WritableStreamDefaultWriter\");\n  const WritableStream = createWritableStreamClass(\n    context,\n    stateMap,\n    writerClassRef\n  );\n  writerClassRef.dispose();\n  context.setProp(context.global, \"WritableStream\", WritableStream);\n  WritableStream.dispose();\n\n  // Create TransformStream class\n  const TransformStream = createTransformStreamClass(context, stateMap);\n  context.setProp(context.global, \"TransformStream\", TransformStream);\n  TransformStream.dispose();\n\n  // Create Blob class with stream factory\n  const BlobClass = createBlobClass(context, stateMap, (source) =>\n    createReadableStream(context, stateMap, source)\n  );\n  context.setProp(context.global, \"Blob\", BlobClass);\n  BlobClass.dispose();\n\n  // Create File class (extends Blob)\n  const blobClassRef = context.getProp(context.global, \"Blob\");\n  const FileClass = createFileClass(context, stateMap, blobClassRef);\n  blobClassRef.dispose();\n  context.setProp(context.global, \"File\", FileClass);\n  FileClass.dispose();\n\n  // Create DOMException class\n  const DOMExceptionClass = createDOMExceptionClass(context, stateMap);\n  context.setProp(context.global, \"DOMException\", DOMExceptionClass);\n  DOMExceptionClass.dispose();\n\n  // Create URLSearchParams class\n  const URLSearchParamsClass = createURLSearchParamsClass(context, stateMap);\n  context.setProp(context.global, \"URLSearchParams\", URLSearchParamsClass);\n  URLSearchParamsClass.dispose();\n\n  // Add Symbol.iterator support for URLSearchParams\n  const urlSearchParamsIteratorResult = context.evalCode(`\n    URLSearchParams.prototype[Symbol.iterator] = function() {\n      return this.entries()[Symbol.iterator]();\n    };\n  `);\n  if (urlSearchParamsIteratorResult.error) {\n    urlSearchParamsIteratorResult.error.dispose();\n  } else {\n    urlSearchParamsIteratorResult.value.dispose();\n  }\n\n  // Create URL class (depends on URLSearchParams)\n  const URLClass = createURLClass(context, stateMap);\n  context.setProp(context.global, \"URL\", URLClass);\n  URLClass.dispose();\n\n  // Add searchParams getter to URL that returns URLSearchParams instance\n  addURLSearchParamsGetter(context);\n\n  /**\n   * @returns CoreHandle with shared stateMap and dispose method\n   *\n   * **dispose() behavior:**\n   * - Clears internal handle tracking array\n   * - Does NOT dispose globals (ReadableStream, Blob, etc.) - they are owned\n   *   by context.global and cleaned up by context.dispose()\n   * - Call before context.dispose() to release internal references\n   *\n   * @see PATTERNS.md for implementation patterns\n   */\n  return {\n    stateMap,\n    dispose() {\n      // Note: handles set on global (ReadableStream, Blob, etc.) are NOT disposed here\n      // They are owned by the global object and will be cleaned up by context.dispose()\n      // Disposing them before context disposal causes QuickJS GC assertion failures\n      handles.length = 0;\n    },\n  };\n}\n\n// Re-export types\nexport type {\n  Scope,\n  MarshalOptions,\n  UnmarshalOptions,\n  PropertyDescriptor,\n  ClassDefinition,\n  StateMap,\n  SetupCoreOptions,\n  CoreHandle,\n  QuickJSContext,\n  QuickJSHandle,\n  QuickJSRuntime,\n} from \"./types.ts\";\nexport { INTERNAL_STATE } from \"./types.ts\";\n\n// Re-export utilities\nexport { withScope, withScopeAsync } from \"./scope.ts\";\nexport { marshal, isHandle, getHandleType } from \"./marshal.ts\";\nexport { unmarshal, cleanupUnmarshaledHandles } from \"./unmarshal.ts\";\nexport { defineFunction, defineAsyncFunction } from \"./function-builder.ts\";\nexport {\n  defineClass,\n  createStateMap,\n  getState,\n  setState,\n  getInstanceState,\n  setInstanceState,\n  getInstanceStateById,\n  cleanupInstanceState,\n  clearAllInstanceState,\n} from \"./class-builder.ts\";\n\n// Re-export stream utilities\nexport {\n  createReadableStream,\n  consumeReadableStream,\n} from \"./streams/readable-stream.ts\";\nexport { createWritableStream } from \"./streams/writable-stream.ts\";\n\n// Re-export Blob/File utilities\nexport { createBlob } from \"./blob.ts\";\nexport { createFile } from \"./file.ts\";\n\n// Re-export URL utilities\nexport { createURLSearchParamsClass } from \"./url-search-params.ts\";\nexport type { URLSearchParamsState } from \"./url-search-params.ts\";\nexport { createURLClass, addURLSearchParamsGetter } from \"./url.ts\";\nexport type { URLState } from \"./url.ts\";\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE+B,IAA/B;AAKO,IAJP;AAQO,IAHP;AAI2C,IAA3C;AACgC,IAAhC;AACgC,IAAhC;AACwC,IAAxC;AAC2C,IAA3C;AACyD,IAAzD;AAuK+B,IAA/B;AAG0C,IAA1C;AACiD,IAAjD;AACqD,IAArD;AACoD,IAApD;AAWO,IAVP;AAgBO,IAHP;AAIqC,IAArC;AAG2B,IAA3B;AAC2B,IAA3B;AAG2C,IAA3C;AAEyD,IAAzD;AA3KO,SAAS,SAAS,CACvB,SACA,SACY;AAAA,EACZ,MAAM,WAAW,SAAS,YAAY,oCAAe;AAAA,EACrD,MAAM,UAAqD,CAAC;AAAA,EAG5D,MAAM,8BAA8B,8DAClC,SACA,QACF;AAAA,EACA,QAAQ,QACN,QAAQ,QACR,+BACA,2BACF;AAAA,EACA,4BAA4B,QAAQ;AAAA,EAGpC,MAAM,iBAAiB,QAAQ,QAAQ,QAAQ,QAAQ,6BAA6B;AAAA,EACpF,MAAM,iBAAiB,iDACrB,SACA,UACA,cACF;AAAA,EACA,eAAe,QAAQ;AAAA,EACvB,QAAQ,QAAQ,QAAQ,QAAQ,kBAAkB,cAAc;AAAA,EAChE,eAAe,QAAQ;AAAA,EAGvB,MAAM,8BAA8B,8DAClC,SACA,QACF;AAAA,EACA,QAAQ,QACN,QAAQ,QACR,+BACA,2BACF;AAAA,EACA,4BAA4B,QAAQ;AAAA,EAGpC,MAAM,iBAAiB,QAAQ,QAAQ,QAAQ,QAAQ,6BAA6B;AAAA,EACpF,MAAM,iBAAiB,iDACrB,SACA,UACA,cACF;AAAA,EACA,eAAe,QAAQ;AAAA,EACvB,QAAQ,QAAQ,QAAQ,QAAQ,kBAAkB,cAAc;AAAA,EAChE,eAAe,QAAQ;AAAA,EAGvB,MAAM,kBAAkB,mDAA2B,SAAS,QAAQ;AAAA,EACpE,QAAQ,QAAQ,QAAQ,QAAQ,mBAAmB,eAAe;AAAA,EAClE,gBAAgB,QAAQ;AAAA,EAGxB,MAAM,YAAY,4BAAgB,SAAS,UAAU,CAAC,WACpD,4CAAqB,SAAS,UAAU,MAAM,CAChD;AAAA,EACA,QAAQ,QAAQ,QAAQ,QAAQ,QAAQ,SAAS;AAAA,EACjD,UAAU,QAAQ;AAAA,EAGlB,MAAM,eAAe,QAAQ,QAAQ,QAAQ,QAAQ,MAAM;AAAA,EAC3D,MAAM,YAAY,4BAAgB,SAAS,UAAU,YAAY;AAAA,EACjE,aAAa,QAAQ;AAAA,EACrB,QAAQ,QAAQ,QAAQ,QAAQ,QAAQ,SAAS;AAAA,EACjD,UAAU,QAAQ;AAAA,EAGlB,MAAM,oBAAoB,6CAAwB,SAAS,QAAQ;AAAA,EACnE,QAAQ,QAAQ,QAAQ,QAAQ,gBAAgB,iBAAiB;AAAA,EACjE,kBAAkB,QAAQ;AAAA,EAG1B,MAAM,uBAAuB,oDAA2B,SAAS,QAAQ;AAAA,EACzE,QAAQ,QAAQ,QAAQ,QAAQ,mBAAmB,oBAAoB;AAAA,EACvE,qBAAqB,QAAQ;AAAA,EAG7B,MAAM,gCAAgC,QAAQ,SAAS;AAAA;AAAA;AAAA;AAAA,GAItD;AAAA,EACD,IAAI,8BAA8B,OAAO;AAAA,IACvC,8BAA8B,MAAM,QAAQ;AAAA,EAC9C,EAAO;AAAA,IACL,8BAA8B,MAAM,QAAQ;AAAA;AAAA,EAI9C,MAAM,WAAW,0BAAe,SAAS,QAAQ;AAAA,EACjD,QAAQ,QAAQ,QAAQ,QAAQ,OAAO,QAAQ;AAAA,EAC/C,SAAS,QAAQ;AAAA,EAGjB,oCAAyB,OAAO;AAAA,EAahC,OAAO;AAAA,IACL;AAAA,IACA,OAAO,GAAG;AAAA,MAIR,QAAQ,SAAS;AAAA;AAAA,EAErB;AAAA;",
+  "debugId": "FE2DEE7125C06AA764756E2164756E21",
+  "names": []
+}

package/dist/cjs/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@ricsam/quickjs-core",
+  "version": "0.2.0",
+  "type": "commonjs"
+}

package/dist/mjs/index.mjs

@@ -0,0 +1,132 @@
+// @bun
+// packages/core/src/index.ts
+import { createStateMap } from "./class-builder.ts";
+import {
+  createReadableStreamClass,
+  createReadableStreamDefaultReaderClass,
+  createReadableStream
+} from "./streams/readable-stream.ts";
+import {
+  createWritableStreamClass,
+  createWritableStreamDefaultWriterClass
+} from "./streams/writable-stream.ts";
+import { createTransformStreamClass } from "./streams/transform-stream.ts";
+import { createBlobClass } from "./blob.ts";
+import { createFileClass } from "./file.ts";
+import { createDOMExceptionClass } from "./dom-exception.ts";
+import { createURLSearchParamsClass } from "./url-search-params.ts";
+import { createURLClass, addURLSearchParamsGetter } from "./url.ts";
+import { INTERNAL_STATE } from "./types.ts";
+import { withScope, withScopeAsync } from "./scope.ts";
+import { marshal, isHandle, getHandleType } from "./marshal.ts";
+import { unmarshal, cleanupUnmarshaledHandles } from "./unmarshal.ts";
+import { defineFunction, defineAsyncFunction } from "./function-builder.ts";
+import {
+  defineClass,
+  createStateMap as createStateMap2,
+  getState,
+  setState,
+  getInstanceState,
+  setInstanceState,
+  getInstanceStateById,
+  cleanupInstanceState,
+  clearAllInstanceState
+} from "./class-builder.ts";
+import {
+  createReadableStream as createReadableStream2,
+  consumeReadableStream
+} from "./streams/readable-stream.ts";
+import { createWritableStream } from "./streams/writable-stream.ts";
+import { createBlob } from "./blob.ts";
+import { createFile } from "./file.ts";
+import { createURLSearchParamsClass as createURLSearchParamsClass2 } from "./url-search-params.ts";
+import { createURLClass as createURLClass2, addURLSearchParamsGetter as addURLSearchParamsGetter2 } from "./url.ts";
+function setupCore(context, options) {
+  const stateMap = options?.stateMap ?? createStateMap();
+  const handles = [];
+  const ReadableStreamDefaultReader = createReadableStreamDefaultReaderClass(context, stateMap);
+  context.setProp(context.global, "ReadableStreamDefaultReader", ReadableStreamDefaultReader);
+  ReadableStreamDefaultReader.dispose();
+  const readerClassRef = context.getProp(context.global, "ReadableStreamDefaultReader");
+  const ReadableStream = createReadableStreamClass(context, stateMap, readerClassRef);
+  readerClassRef.dispose();
+  context.setProp(context.global, "ReadableStream", ReadableStream);
+  ReadableStream.dispose();
+  const WritableStreamDefaultWriter = createWritableStreamDefaultWriterClass(context, stateMap);
+  context.setProp(context.global, "WritableStreamDefaultWriter", WritableStreamDefaultWriter);
+  WritableStreamDefaultWriter.dispose();
+  const writerClassRef = context.getProp(context.global, "WritableStreamDefaultWriter");
+  const WritableStream = createWritableStreamClass(context, stateMap, writerClassRef);
+  writerClassRef.dispose();
+  context.setProp(context.global, "WritableStream", WritableStream);
+  WritableStream.dispose();
+  const TransformStream = createTransformStreamClass(context, stateMap);
+  context.setProp(context.global, "TransformStream", TransformStream);
+  TransformStream.dispose();
+  const BlobClass = createBlobClass(context, stateMap, (source) => createReadableStream(context, stateMap, source));
+  context.setProp(context.global, "Blob", BlobClass);
+  BlobClass.dispose();
+  const blobClassRef = context.getProp(context.global, "Blob");
+  const FileClass = createFileClass(context, stateMap, blobClassRef);
+  blobClassRef.dispose();
+  context.setProp(context.global, "File", FileClass);
+  FileClass.dispose();
+  const DOMExceptionClass = createDOMExceptionClass(context, stateMap);
+  context.setProp(context.global, "DOMException", DOMExceptionClass);
+  DOMExceptionClass.dispose();
+  const URLSearchParamsClass = createURLSearchParamsClass(context, stateMap);
+  context.setProp(context.global, "URLSearchParams", URLSearchParamsClass);
+  URLSearchParamsClass.dispose();
+  const urlSearchParamsIteratorResult = context.evalCode(`
+    URLSearchParams.prototype[Symbol.iterator] = function() {
+      return this.entries()[Symbol.iterator]();
+    };
+  `);
+  if (urlSearchParamsIteratorResult.error) {
+    urlSearchParamsIteratorResult.error.dispose();
+  } else {
+    urlSearchParamsIteratorResult.value.dispose();
+  }
+  const URLClass = createURLClass(context, stateMap);
+  context.setProp(context.global, "URL", URLClass);
+  URLClass.dispose();
+  addURLSearchParamsGetter(context);
+  return {
+    stateMap,
+    dispose() {
+      handles.length = 0;
+    }
+  };
+}
+export {
+  withScopeAsync,
+  withScope,
+  unmarshal,
+  setupCore,
+  setState,
+  setInstanceState,
+  marshal,
+  isHandle,
+  getState,
+  getInstanceStateById,
+  getInstanceState,
+  getHandleType,
+  defineFunction,
+  defineClass,
+  defineAsyncFunction,
+  createWritableStream,
+  createURLSearchParamsClass2 as createURLSearchParamsClass,
+  createURLClass2 as createURLClass,
+  createStateMap2 as createStateMap,
+  createReadableStream2 as createReadableStream,
+  createFile,
+  createBlob,
+  consumeReadableStream,
+  clearAllInstanceState,
+  cleanupUnmarshaledHandles,
+  cleanupInstanceState,
+  addURLSearchParamsGetter2 as addURLSearchParamsGetter,
+  INTERNAL_STATE
+};
+
+//# debugId=E3F9214AFACC87A464756E2164756E21

package/dist/mjs/index.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": [
+    "import type { QuickJSContext, QuickJSHandle } from \"quickjs-emscripten\";\nimport type { SetupCoreOptions, CoreHandle, StateMap } from \"./types.ts\";\nimport { createStateMap } from \"./class-builder.ts\";\nimport {\n  createReadableStreamClass,\n  createReadableStreamDefaultReaderClass,\n  createReadableStream,\n} from \"./streams/readable-stream.ts\";\nimport {\n  createWritableStreamClass,\n  createWritableStreamDefaultWriterClass,\n} from \"./streams/writable-stream.ts\";\nimport { createTransformStreamClass } from \"./streams/transform-stream.ts\";\nimport { createBlobClass } from \"./blob.ts\";\nimport { createFileClass } from \"./file.ts\";\nimport { createDOMExceptionClass } from \"./dom-exception.ts\";\nimport { createURLSearchParamsClass } from \"./url-search-params.ts\";\nimport { createURLClass, addURLSearchParamsGetter } from \"./url.ts\";\n\n/**\n * Setup core APIs in a QuickJS context\n *\n * Injects the following globals:\n * - ReadableStream, WritableStream, TransformStream\n * - ReadableStreamDefaultReader, WritableStreamDefaultWriter\n * - Blob\n * - File\n * - DOMException\n * - URL, URLSearchParams\n *\n * @example\n * const handle = setupCore(context);\n *\n * context.evalCode(`\n *   const blob = new Blob([\"hello\", \" \", \"world\"], { type: \"text/plain\" });\n *   const text = await blob.text(); // \"hello world\"\n *\n *   const stream = new ReadableStream({\n *     start(controller) {\n *       controller.enqueue(\"chunk1\");\n *       controller.enqueue(\"chunk2\");\n *       controller.close();\n *     }\n *   });\n * `);\n */\nexport function setupCore(\n  context: QuickJSContext,\n  options?: SetupCoreOptions\n): CoreHandle {\n  const stateMap = options?.stateMap ?? createStateMap();\n  const handles: { name: string; handle: QuickJSHandle }[] = [];\n\n  // Create ReadableStreamDefaultReader class first\n  const ReadableStreamDefaultReader = createReadableStreamDefaultReaderClass(\n    context,\n    stateMap\n  );\n  context.setProp(\n    context.global,\n    \"ReadableStreamDefaultReader\",\n    ReadableStreamDefaultReader\n  );\n  ReadableStreamDefaultReader.dispose();\n\n  // Create ReadableStream class\n  const readerClassRef = context.getProp(context.global, \"ReadableStreamDefaultReader\");\n  const ReadableStream = createReadableStreamClass(\n    context,\n    stateMap,\n    readerClassRef\n  );\n  readerClassRef.dispose();\n  context.setProp(context.global, \"ReadableStream\", ReadableStream);\n  ReadableStream.dispose();\n\n  // Create WritableStreamDefaultWriter class first\n  const WritableStreamDefaultWriter = createWritableStreamDefaultWriterClass(\n    context,\n    stateMap\n  );\n  context.setProp(\n    context.global,\n    \"WritableStreamDefaultWriter\",\n    WritableStreamDefaultWriter\n  );\n  WritableStreamDefaultWriter.dispose();\n\n  // Create WritableStream class\n  const writerClassRef = context.getProp(context.global, \"WritableStreamDefaultWriter\");\n  const WritableStream = createWritableStreamClass(\n    context,\n    stateMap,\n    writerClassRef\n  );\n  writerClassRef.dispose();\n  context.setProp(context.global, \"WritableStream\", WritableStream);\n  WritableStream.dispose();\n\n  // Create TransformStream class\n  const TransformStream = createTransformStreamClass(context, stateMap);\n  context.setProp(context.global, \"TransformStream\", TransformStream);\n  TransformStream.dispose();\n\n  // Create Blob class with stream factory\n  const BlobClass = createBlobClass(context, stateMap, (source) =>\n    createReadableStream(context, stateMap, source)\n  );\n  context.setProp(context.global, \"Blob\", BlobClass);\n  BlobClass.dispose();\n\n  // Create File class (extends Blob)\n  const blobClassRef = context.getProp(context.global, \"Blob\");\n  const FileClass = createFileClass(context, stateMap, blobClassRef);\n  blobClassRef.dispose();\n  context.setProp(context.global, \"File\", FileClass);\n  FileClass.dispose();\n\n  // Create DOMException class\n  const DOMExceptionClass = createDOMExceptionClass(context, stateMap);\n  context.setProp(context.global, \"DOMException\", DOMExceptionClass);\n  DOMExceptionClass.dispose();\n\n  // Create URLSearchParams class\n  const URLSearchParamsClass = createURLSearchParamsClass(context, stateMap);\n  context.setProp(context.global, \"URLSearchParams\", URLSearchParamsClass);\n  URLSearchParamsClass.dispose();\n\n  // Add Symbol.iterator support for URLSearchParams\n  const urlSearchParamsIteratorResult = context.evalCode(`\n    URLSearchParams.prototype[Symbol.iterator] = function() {\n      return this.entries()[Symbol.iterator]();\n    };\n  `);\n  if (urlSearchParamsIteratorResult.error) {\n    urlSearchParamsIteratorResult.error.dispose();\n  } else {\n    urlSearchParamsIteratorResult.value.dispose();\n  }\n\n  // Create URL class (depends on URLSearchParams)\n  const URLClass = createURLClass(context, stateMap);\n  context.setProp(context.global, \"URL\", URLClass);\n  URLClass.dispose();\n\n  // Add searchParams getter to URL that returns URLSearchParams instance\n  addURLSearchParamsGetter(context);\n\n  /**\n   * @returns CoreHandle with shared stateMap and dispose method\n   *\n   * **dispose() behavior:**\n   * - Clears internal handle tracking array\n   * - Does NOT dispose globals (ReadableStream, Blob, etc.) - they are owned\n   *   by context.global and cleaned up by context.dispose()\n   * - Call before context.dispose() to release internal references\n   *\n   * @see PATTERNS.md for implementation patterns\n   */\n  return {\n    stateMap,\n    dispose() {\n      // Note: handles set on global (ReadableStream, Blob, etc.) are NOT disposed here\n      // They are owned by the global object and will be cleaned up by context.dispose()\n      // Disposing them before context disposal causes QuickJS GC assertion failures\n      handles.length = 0;\n    },\n  };\n}\n\n// Re-export types\nexport type {\n  Scope,\n  MarshalOptions,\n  UnmarshalOptions,\n  PropertyDescriptor,\n  ClassDefinition,\n  StateMap,\n  SetupCoreOptions,\n  CoreHandle,\n  QuickJSContext,\n  QuickJSHandle,\n  QuickJSRuntime,\n} from \"./types.ts\";\nexport { INTERNAL_STATE } from \"./types.ts\";\n\n// Re-export utilities\nexport { withScope, withScopeAsync } from \"./scope.ts\";\nexport { marshal, isHandle, getHandleType } from \"./marshal.ts\";\nexport { unmarshal, cleanupUnmarshaledHandles } from \"./unmarshal.ts\";\nexport { defineFunction, defineAsyncFunction } from \"./function-builder.ts\";\nexport {\n  defineClass,\n  createStateMap,\n  getState,\n  setState,\n  getInstanceState,\n  setInstanceState,\n  getInstanceStateById,\n  cleanupInstanceState,\n  clearAllInstanceState,\n} from \"./class-builder.ts\";\n\n// Re-export stream utilities\nexport {\n  createReadableStream,\n  consumeReadableStream,\n} from \"./streams/readable-stream.ts\";\nexport { createWritableStream } from \"./streams/writable-stream.ts\";\n\n// Re-export Blob/File utilities\nexport { createBlob } from \"./blob.ts\";\nexport { createFile } from \"./file.ts\";\n\n// Re-export URL utilities\nexport { createURLSearchParamsClass } from \"./url-search-params.ts\";\nexport type { URLSearchParamsState } from \"./url-search-params.ts\";\nexport { createURLClass, addURLSearchParamsGetter } from \"./url.ts\";\nexport type { URLState } from \"./url.ts\";\n"
+  ],
+  "mappings": ";;AAEA;AACA;AAAA;AAAA;AAAA;AAAA;AAKA;AAAA;AAAA;AAAA;AAIA;AACA;AACA;AACA;AACA;AACA;AAuKA;AAGA;AACA;AACA;AACA;AACA;AAAA;AAAA,oBAEE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWF;AAAA,0BACE;AAAA;AAAA;AAGF;AAGA;AACA;AAGA,uCAAS;AAET,2BAAS,6CAAgB;AA3KlB,SAAS,SAAS,CACvB,SACA,SACY;AAAA,EACZ,MAAM,WAAW,SAAS,YAAY,eAAe;AAAA,EACrD,MAAM,UAAqD,CAAC;AAAA,EAG5D,MAAM,8BAA8B,uCAClC,SACA,QACF;AAAA,EACA,QAAQ,QACN,QAAQ,QACR,+BACA,2BACF;AAAA,EACA,4BAA4B,QAAQ;AAAA,EAGpC,MAAM,iBAAiB,QAAQ,QAAQ,QAAQ,QAAQ,6BAA6B;AAAA,EACpF,MAAM,iBAAiB,0BACrB,SACA,UACA,cACF;AAAA,EACA,eAAe,QAAQ;AAAA,EACvB,QAAQ,QAAQ,QAAQ,QAAQ,kBAAkB,cAAc;AAAA,EAChE,eAAe,QAAQ;AAAA,EAGvB,MAAM,8BAA8B,uCAClC,SACA,QACF;AAAA,EACA,QAAQ,QACN,QAAQ,QACR,+BACA,2BACF;AAAA,EACA,4BAA4B,QAAQ;AAAA,EAGpC,MAAM,iBAAiB,QAAQ,QAAQ,QAAQ,QAAQ,6BAA6B;AAAA,EACpF,MAAM,iBAAiB,0BACrB,SACA,UACA,cACF;AAAA,EACA,eAAe,QAAQ;AAAA,EACvB,QAAQ,QAAQ,QAAQ,QAAQ,kBAAkB,cAAc;AAAA,EAChE,eAAe,QAAQ;AAAA,EAGvB,MAAM,kBAAkB,2BAA2B,SAAS,QAAQ;AAAA,EACpE,QAAQ,QAAQ,QAAQ,QAAQ,mBAAmB,eAAe;AAAA,EAClE,gBAAgB,QAAQ;AAAA,EAGxB,MAAM,YAAY,gBAAgB,SAAS,UAAU,CAAC,WACpD,qBAAqB,SAAS,UAAU,MAAM,CAChD;AAAA,EACA,QAAQ,QAAQ,QAAQ,QAAQ,QAAQ,SAAS;AAAA,EACjD,UAAU,QAAQ;AAAA,EAGlB,MAAM,eAAe,QAAQ,QAAQ,QAAQ,QAAQ,MAAM;AAAA,EAC3D,MAAM,YAAY,gBAAgB,SAAS,UAAU,YAAY;AAAA,EACjE,aAAa,QAAQ;AAAA,EACrB,QAAQ,QAAQ,QAAQ,QAAQ,QAAQ,SAAS;AAAA,EACjD,UAAU,QAAQ;AAAA,EAGlB,MAAM,oBAAoB,wBAAwB,SAAS,QAAQ;AAAA,EACnE,QAAQ,QAAQ,QAAQ,QAAQ,gBAAgB,iBAAiB;AAAA,EACjE,kBAAkB,QAAQ;AAAA,EAG1B,MAAM,uBAAuB,2BAA2B,SAAS,QAAQ;AAAA,EACzE,QAAQ,QAAQ,QAAQ,QAAQ,mBAAmB,oBAAoB;AAAA,EACvE,qBAAqB,QAAQ;AAAA,EAG7B,MAAM,gCAAgC,QAAQ,SAAS;AAAA;AAAA;AAAA;AAAA,GAItD;AAAA,EACD,IAAI,8BAA8B,OAAO;AAAA,IACvC,8BAA8B,MAAM,QAAQ;AAAA,EAC9C,EAAO;AAAA,IACL,8BAA8B,MAAM,QAAQ;AAAA;AAAA,EAI9C,MAAM,WAAW,eAAe,SAAS,QAAQ;AAAA,EACjD,QAAQ,QAAQ,QAAQ,QAAQ,OAAO,QAAQ;AAAA,EAC/C,SAAS,QAAQ;AAAA,EAGjB,yBAAyB,OAAO;AAAA,EAahC,OAAO;AAAA,IACL;AAAA,IACA,OAAO,GAAG;AAAA,MAIR,QAAQ,SAAS;AAAA;AAAA,EAErB;AAAA;",
+  "debugId": "E3F9214AFACC87A464756E2164756E21",
+  "names": []
+}

package/dist/mjs/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@ricsam/quickjs-core",
+  "version": "0.2.0",
+  "type": "module"
+}

package/dist/types/blob.d.ts

@@ -0,0 +1,19 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap } from "./types.ts";
+/**
+ * Type for the stream factory function
+ */
+type StreamFactory = (source: UnderlyingSource) => QuickJSHandle;
+/**
+ * Create the Blob class for QuickJS
+ *
+ * @param context - QuickJS context
+ * @param stateMap - State map for internal state tracking
+ * @param createStream - Factory function to create ReadableStream handles
+ */
+export declare function createBlobClass(context: QuickJSContext, stateMap: StateMap, createStream: StreamFactory): QuickJSHandle;
+/**
+ * Create a Blob in QuickJS from host data
+ */
+export declare function createBlob(context: QuickJSContext, stateMap: StateMap, parts: BlobPart[], options?: BlobPropertyBag): QuickJSHandle;
+export {};

package/dist/types/class-builder.d.ts

@@ -0,0 +1,62 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { ClassDefinition, StateMap } from "./types.ts";
+/**
+ * Create a new StateMap for tracking object internal states
+ */
+export declare function createStateMap(): StateMap;
+/**
+ * Get the internal state associated with a QuickJS object handle
+ */
+export declare function getState<T extends object>(stateMap: StateMap, handle: QuickJSHandle): T | undefined;
+/**
+ * Set the internal state associated with a QuickJS object handle
+ */
+export declare function setState<T extends object>(stateMap: StateMap, handle: QuickJSHandle, state: T): void;
+/**
+ * Define a class in the QuickJS context
+ *
+ * Uses evalCode to create a proper JavaScript class that can be called with 'new'.
+ * Host-side callbacks are registered and invoked by the JavaScript class.
+ *
+ * @returns Handle to the class constructor (caller must manage disposal)
+ *
+ * @example
+ * const Point = defineClass(context, stateMap, {
+ *   name: "Point",
+ *   construct: ([x, y]) => ({ x: Number(x), y: Number(y) }),
+ *   methods: {
+ *     distance(this: { x: number; y: number }) {
+ *       return Math.sqrt(this.x ** 2 + this.y ** 2);
+ *     }
+ *   },
+ *   properties: {
+ *     x: {
+ *       get(this: { x: number }) { return this.x; },
+ *       set(this: { x: number }, v: unknown) { this.x = Number(v); }
+ *     }
+ *   }
+ * });
+ * context.setProp(context.global, "Point", Point);
+ */
+export declare function defineClass<TState extends object>(context: QuickJSContext, stateMap: StateMap, definition: ClassDefinition<TState>): QuickJSHandle;
+/**
+ * Get internal state for a QuickJS instance by extracting its __instanceId__
+ */
+export declare function getInstanceState<T>(context: QuickJSContext, instanceHandle: QuickJSHandle): T | undefined;
+/**
+ * Set internal state for a QuickJS instance by extracting its __instanceId__
+ */
+export declare function setInstanceState<T>(context: QuickJSContext, instanceHandle: QuickJSHandle, state: T): void;
+/**
+ * Get internal state by instance ID directly
+ * Useful when you have the instanceId from an unmarshaled object
+ */
+export declare function getInstanceStateById<T>(instanceId: number): T | undefined;
+/**
+ * Clean up instance state when an instance is no longer needed
+ */
+export declare function cleanupInstanceState(instanceId: number): void;
+/**
+ * Clear all instance state (useful for context disposal or testing cleanup)
+ */
+export declare function clearAllInstanceState(): void;

package/dist/types/dom-exception.d.ts

@@ -0,0 +1,8 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap } from "./types.ts";
+export interface DOMExceptionState {
+    message: string;
+    name: string;
+    code: number;
+}
+export declare function createDOMExceptionClass(context: QuickJSContext, stateMap: StateMap): QuickJSHandle;

package/dist/types/file.d.ts

@@ -0,0 +1,10 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap } from "./types.ts";
+/**
+ * Create the File class for QuickJS (extends Blob)
+ */
+export declare function createFileClass(context: QuickJSContext, stateMap: StateMap, _blobClass: QuickJSHandle): QuickJSHandle;
+/**
+ * Create a File in QuickJS from host data
+ */
+export declare function createFile(context: QuickJSContext, stateMap: StateMap, parts: BlobPart[], name: string, options?: FilePropertyBag): QuickJSHandle;

package/dist/types/function-builder.d.ts

@@ -0,0 +1,23 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+/**
+ * Define a global function in the QuickJS context
+ *
+ * @returns Handle to the function (caller must manage disposal)
+ *
+ * @example
+ * const logFn = defineFunction(context, "log", (...args) => {
+ *   console.log("[QuickJS]", ...args);
+ * });
+ * context.setProp(context.global, "log", logFn);
+ */
+export declare function defineFunction(context: QuickJSContext, name: string, fn: (...args: unknown[]) => unknown): QuickJSHandle;
+/**
+ * Define an async function that returns a promise to QuickJS
+ *
+ * @example
+ * const fetchFn = defineAsyncFunction(context, "fetch", async (url) => {
+ *   const response = await fetch(String(url));
+ *   return response.text();
+ * });
+ */
+export declare function defineAsyncFunction(context: QuickJSContext, name: string, fn: (...args: unknown[]) => Promise<unknown>): QuickJSHandle;

package/dist/types/index.d.ts

@@ -0,0 +1,45 @@
+import type { QuickJSContext } from "quickjs-emscripten";
+import type { SetupCoreOptions, CoreHandle } from "./types.ts";
+/**
+ * Setup core APIs in a QuickJS context
+ *
+ * Injects the following globals:
+ * - ReadableStream, WritableStream, TransformStream
+ * - ReadableStreamDefaultReader, WritableStreamDefaultWriter
+ * - Blob
+ * - File
+ * - DOMException
+ * - URL, URLSearchParams
+ *
+ * @example
+ * const handle = setupCore(context);
+ *
+ * context.evalCode(`
+ *   const blob = new Blob(["hello", " ", "world"], { type: "text/plain" });
+ *   const text = await blob.text(); // "hello world"
+ *
+ *   const stream = new ReadableStream({
+ *     start(controller) {
+ *       controller.enqueue("chunk1");
+ *       controller.enqueue("chunk2");
+ *       controller.close();
+ *     }
+ *   });
+ * `);
+ */
+export declare function setupCore(context: QuickJSContext, options?: SetupCoreOptions): CoreHandle;
+export type { Scope, MarshalOptions, UnmarshalOptions, PropertyDescriptor, ClassDefinition, StateMap, SetupCoreOptions, CoreHandle, QuickJSContext, QuickJSHandle, QuickJSRuntime, } from "./types.ts";
+export { INTERNAL_STATE } from "./types.ts";
+export { withScope, withScopeAsync } from "./scope.ts";
+export { marshal, isHandle, getHandleType } from "./marshal.ts";
+export { unmarshal, cleanupUnmarshaledHandles } from "./unmarshal.ts";
+export { defineFunction, defineAsyncFunction } from "./function-builder.ts";
+export { defineClass, createStateMap, getState, setState, getInstanceState, setInstanceState, getInstanceStateById, cleanupInstanceState, clearAllInstanceState, } from "./class-builder.ts";
+export { createReadableStream, consumeReadableStream, } from "./streams/readable-stream.ts";
+export { createWritableStream } from "./streams/writable-stream.ts";
+export { createBlob } from "./blob.ts";
+export { createFile } from "./file.ts";
+export { createURLSearchParamsClass } from "./url-search-params.ts";
+export type { URLSearchParamsState } from "./url-search-params.ts";
+export { createURLClass, addURLSearchParamsGetter } from "./url.ts";
+export type { URLState } from "./url.ts";

package/dist/types/marshal.d.ts

@@ -0,0 +1,30 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { MarshalOptions } from "./types.ts";
+/**
+ * Check if a value is a QuickJS handle
+ */
+export declare function isHandle(value: unknown): value is QuickJSHandle;
+/**
+ * Get the type of a QuickJS handle as a string
+ */
+export declare function getHandleType(context: QuickJSContext, handle: QuickJSHandle): "undefined" | "null" | "boolean" | "number" | "string" | "symbol" | "object" | "function";
+/**
+ * Marshal a JavaScript value to a QuickJS handle
+ *
+ * Supports:
+ * - Primitives (string, number, boolean, null, undefined, bigint)
+ * - Arrays
+ * - Plain objects
+ * - ArrayBuffer / Uint8Array
+ * - Date (converted to Date object in QuickJS)
+ * - Functions (wrapped as host functions)
+ * - Promises (wrapped with context.newPromise)
+ *
+ * @example
+ * const handle = marshal(context, {
+ *   name: "test",
+ *   values: [1, 2, 3],
+ *   callback: (x) => x * 2
+ * });
+ */
+export declare function marshal(context: QuickJSContext, value: unknown, options?: MarshalOptions): QuickJSHandle;

package/dist/types/scope.d.ts

@@ -0,0 +1,18 @@
+import type { QuickJSContext } from "quickjs-emscripten";
+import type { Scope } from "./types.ts";
+/**
+ * Execute a function with automatic handle cleanup
+ *
+ * @example
+ * const result = withScope(context, (scope) => {
+ *   const obj = scope.manage(context.newObject());
+ *   const str = scope.manage(context.newString("hello"));
+ *   context.setProp(obj, "message", str);
+ *   return context.dump(obj);
+ * });
+ */
+export declare function withScope<T>(_context: QuickJSContext, fn: (scope: Scope) => T): T;
+/**
+ * Async version of withScope for promise-based operations
+ */
+export declare function withScopeAsync<T>(_context: QuickJSContext, fn: (scope: Scope) => Promise<T>): Promise<T>;

package/dist/types/streams/readable-stream.d.ts

@@ -0,0 +1,18 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap } from "../types.ts";
+/**
+ * Create the ReadableStreamDefaultReader class
+ */
+export declare function createReadableStreamDefaultReaderClass(context: QuickJSContext, stateMap: StateMap): QuickJSHandle;
+/**
+ * Create the ReadableStream class
+ */
+export declare function createReadableStreamClass(context: QuickJSContext, stateMap: StateMap, readerClass: QuickJSHandle): QuickJSHandle;
+/**
+ * Create a ReadableStream in QuickJS from a host-side source
+ */
+export declare function createReadableStream(context: QuickJSContext, stateMap: StateMap, source: UnderlyingSource): QuickJSHandle;
+/**
+ * Consume a ReadableStream from QuickJS in the host
+ */
+export declare function consumeReadableStream(context: QuickJSContext, stateMap: StateMap, streamHandle: QuickJSHandle): AsyncIterable<unknown>;

package/dist/types/streams/transform-stream.d.ts

@@ -0,0 +1,6 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap } from "../types.ts";
+/**
+ * Create the TransformStream class
+ */
+export declare function createTransformStreamClass(context: QuickJSContext, stateMap: StateMap): QuickJSHandle;

package/dist/types/streams/writable-stream.d.ts

@@ -0,0 +1,14 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap } from "../types.ts";
+/**
+ * Create the WritableStreamDefaultWriter class
+ */
+export declare function createWritableStreamDefaultWriterClass(context: QuickJSContext, stateMap: StateMap): QuickJSHandle;
+/**
+ * Create the WritableStream class
+ */
+export declare function createWritableStreamClass(context: QuickJSContext, stateMap: StateMap, writerClass: QuickJSHandle): QuickJSHandle;
+/**
+ * Create a WritableStream in QuickJS from a host-side sink
+ */
+export declare function createWritableStream(context: QuickJSContext, stateMap: StateMap, sink: UnderlyingSink): QuickJSHandle;

package/dist/types/types.d.ts

@@ -0,0 +1,83 @@
+import type { QuickJSContext, QuickJSHandle, QuickJSRuntime } from "quickjs-emscripten";
+export type { QuickJSContext, QuickJSHandle, QuickJSRuntime };
+/**
+ * A scope for automatic handle cleanup
+ */
+export interface Scope {
+    /** Track a handle for cleanup when scope ends */
+    manage<T extends QuickJSHandle>(handle: T): T;
+    /** Get all managed handles */
+    readonly handles: readonly QuickJSHandle[];
+}
+/**
+ * Options for marshalling values
+ */
+export interface MarshalOptions {
+    /** Maximum depth for nested objects (default: 10) */
+    maxDepth?: number;
+    /** Custom marshaller for specific types */
+    custom?: (value: unknown, context: QuickJSContext) => QuickJSHandle | undefined;
+}
+/**
+ * Options for unmarshalling values
+ */
+export interface UnmarshalOptions {
+    /** Maximum depth for nested objects (default: 10) */
+    maxDepth?: number;
+    /** Custom unmarshaller for specific handles */
+    custom?: (handle: QuickJSHandle, context: QuickJSContext) => unknown | undefined;
+}
+/**
+ * Property descriptor for class builder
+ */
+export interface PropertyDescriptor<TState = unknown> {
+    get?: (this: TState) => any;
+    set?: (this: TState, value: any) => void;
+    value?: unknown;
+    writable?: boolean;
+    enumerable?: boolean;
+    configurable?: boolean;
+}
+/**
+ * Options for defining a class
+ */
+export interface ClassDefinition<TState extends object = object> {
+    /** Class name */
+    name: string;
+    /** Constructor function - receives unmarshalled args, returns internal state */
+    construct?: (args: unknown[]) => TState;
+    /** Prototype methods */
+    methods?: Record<string, (this: TState, ...args: unknown[]) => unknown>;
+    /** Prototype getters/setters */
+    properties?: Record<string, PropertyDescriptor<TState>>;
+    /** Static methods */
+    staticMethods?: Record<string, (...args: unknown[]) => unknown>;
+    /** Static properties */
+    staticProperties?: Record<string, unknown>;
+    /** Parent class handle (for inheritance) */
+    extends?: QuickJSHandle;
+}
+/**
+ * Symbol used to store internal state on QuickJS class instances
+ */
+export declare const INTERNAL_STATE: unique symbol;
+/**
+ * Map to store internal state for QuickJS object handles
+ */
+export type StateMap = WeakMap<QuickJSHandle, object>;
+/**
+ * Options for setting up core APIs
+ */
+export interface SetupCoreOptions {
+    /** Existing state map to use (creates new one if not provided) */
+    stateMap?: StateMap;
+}
+/**
+ * Handle returned from setupCore
+ */
+export interface CoreHandle {
+    /** State map containing internal states */
+    readonly stateMap: StateMap;
+    /** Dispose all handles */
+    dispose(): void;
+}

package/dist/types/unmarshal.d.ts

@@ -0,0 +1,14 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { UnmarshalOptions } from "./types.ts";
+/**
+ * Clean up all duped handles for a context
+ * Should be called before disposing the context
+ */
+export declare function cleanupUnmarshaledHandles(context: QuickJSContext): void;
+/**
+ * Unmarshal a QuickJS handle to a JavaScript value
+ *
+ * @example
+ * const value = unmarshal(context, handle);
+ */
+export declare function unmarshal(context: QuickJSContext, handle: QuickJSHandle, options?: UnmarshalOptions): unknown;

package/dist/types/url-search-params.d.ts

@@ -0,0 +1,12 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap } from "./types.ts";
+/**
+ * Internal state for URLSearchParams
+ */
+export interface URLSearchParamsState {
+    params: [string, string][];
+}
+/**
+ * Create the URLSearchParams class for QuickJS
+ */
+export declare function createURLSearchParamsClass(context: QuickJSContext, stateMap: StateMap): QuickJSHandle;

package/dist/types/url.d.ts

@@ -0,0 +1,30 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap } from "./types.ts";
+/**
+ * Internal state for URL
+ */
+export interface URLState {
+    hash: string;
+    host: string;
+    hostname: string;
+    href: string;
+    origin: string;
+    password: string;
+    pathname: string;
+    port: string;
+    protocol: string;
+    search: string;
+    username: string;
+}
+/**
+ * Create the URL class for QuickJS
+ *
+ * Note: The searchParams property is added separately via evalCode
+ * after this class is registered, as it needs to return a URLSearchParams instance.
+ */
+export declare function createURLClass(context: QuickJSContext, stateMap: StateMap): QuickJSHandle;
+/**
+ * Add searchParams getter to URL prototype using evalCode
+ * This must be called after both URL and URLSearchParams are registered as globals
+ */
+export declare function addURLSearchParamsGetter(context: QuickJSContext): void;

package/package.json

@@ -1,10 +1,54 @@
 {
   "name": "@ricsam/quickjs-core",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @ricsam/quickjs-core",
+  "version": "0.2.0",
+  "main": "./dist/cjs/index.cjs",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/cjs/index.cjs",
+      "import": "./dist/mjs/index.mjs"
+    }
+  },
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "quickjs-emscripten": "^0.31.0"
+  },
+  "peerDependencies": {
+    "quickjs-emscripten": "^0.31.0"
+  },
+  "author": "Richard Samuelsson",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ricsam/richie-qjs.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ricsam/richie-qjs/issues"
+  },
+  "homepage": "https://github.com/ricsam/richie-qjs#readme",
   "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
+    "quickjs",
+    "sandbox",
+    "javascript",
+    "runtime",
+    "fetch",
+    "filesystem",
+    "streams",
+    "wasm",
+    "emscripten"
+  ],
+  "description": "Core utilities and class builder for QuickJS runtime bindings",
+  "module": "./dist/mjs/index.mjs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
   ]
-}
+}