@ricsam/quickjs-fetch 0.0.1 → 0.2.0

package/README.md

@@ -1,45 +1,111 @@
 # @ricsam/quickjs-fetch
 
-## ⚠️ 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-fetch`
-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**
+Fetch API and HTTP server handler.
+
+```typescript
+import { setupFetch } from "@ricsam/quickjs-fetch";
+
+const handle = setupFetch(context, {
+  onFetch: async (request) => {
+    // Handle outbound fetch() calls from QuickJS
+    console.log(`Fetching: ${request.url}`);
+    return fetch(request);
+  },
+});
+```
+
+**Injected Globals:**
+- `fetch`, `Request`, `Response`, `Headers`
+- `FormData`, `AbortController`, `AbortSignal`
+- `serve` (HTTP server handler)
+
+**Usage in QuickJS:**
+
+```javascript
+// Outbound fetch
+const response = await fetch("https://api.example.com/data");
+const data = await response.json();
+
+// Request/Response
+const request = new Request("https://example.com", {
+  method: "POST",
+  headers: { "Content-Type": "application/json" },
+  body: JSON.stringify({ name: "test" }),
+});
+
+const response = new Response(JSON.stringify({ ok: true }), {
+  status: 200,
+  headers: { "Content-Type": "application/json" },
+});
+
+// Static methods
+Response.json({ message: "hello" });
+Response.redirect("https://example.com", 302);
+
+// AbortController
+const controller = new AbortController();
+setTimeout(() => controller.abort(), 5000);
+await fetch(url, { signal: controller.signal });
+
+// FormData
+const formData = new FormData();
+formData.append("name", "John");
+formData.append("file", new File(["content"], "file.txt"));
+```
+
+#### HTTP Server
+
+Register a server handler in QuickJS and dispatch requests from the host:
+
+```typescript
+// In QuickJS
+context.evalCode(`
+  serve({
+    fetch(request, server) {
+      const url = new URL(request.url);
+
+      if (url.pathname === "/ws") {
+        if (server.upgrade(request, { data: { userId: "123" } })) {
+          return new Response(null, { status: 101 });
+        }
+      }
+
+      return Response.json({ path: url.pathname });
+    },
+    websocket: {
+      open(ws) {
+        console.log("Connected:", ws.data.userId);
+      },
+      message(ws, message) {
+        ws.send("Echo: " + message);
+      },
+      close(ws, code, reason) {
+        console.log("Closed:", code, reason);
+      }
+    }
+  });
+`);
+
+// From host - dispatch HTTP request
+const response = await handle.dispatchRequest(
+  new Request("http://localhost/api/users")
+);
+
+// Check for WebSocket upgrade
+const upgrade = handle.getUpgradeRequest();
+if (upgrade?.requested) {
+  // Handle WebSocket connection
+  const connectionId = crypto.randomUUID();
+  handle.dispatchWebSocketOpen(connectionId, upgrade.data);
+
+  // Listen for outgoing messages
+  handle.onWebSocketCommand((command) => {
+    if (command.type === "message") {
+      // Send to actual WebSocket client
+    }
+  });
+
+  // Forward incoming messages
+  handle.dispatchWebSocketMessage(connectionId, "Hello from client");
+}
+```

package/dist/cjs/index.cjs

@@ -0,0 +1,47 @@
+// @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/fetch/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  setupFetch: () => import_setup.setupFetch,
+  responseStateToNative: () => import_response.responseStateToNative,
+  headersStateToNative: () => import_headers.headersStateToNative,
+  createResponseStateFromNative: () => import_response.createResponseStateFromNative,
+  createRequestStateFromNative: () => import_request.createRequestStateFromNative,
+  createHeadersStateFromNative: () => import_headers.createHeadersStateFromNative
+});
+module.exports = __toCommonJS(exports_src);
+var import_setup = require("./setup.ts");
+var import_headers = require("./globals/headers.ts");
+var import_response = require("./globals/response.ts");
+var import_request = require("./globals/request.ts");
+})
+
+//# debugId=1A00B620C92685AE64756E2164756E21

package/dist/cjs/index.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": [
+    "export { setupFetch } from \"./setup.ts\";\n\nexport type {\n  SetupFetchOptions,\n  FetchHandle,\n  WebSocketData,\n  UpgradeRequest,\n  WebSocketCommand,\n  WebSocketOutgoingMessage,\n  WebSocketClose,\n  ServeState,\n  ServerWebSocketState,\n} from \"./types.ts\";\n\n// Re-export utilities that might be useful\nexport {\n  createHeadersStateFromNative,\n  headersStateToNative,\n} from \"./globals/headers.ts\";\nexport {\n  responseStateToNative,\n  createResponseStateFromNative,\n} from \"./globals/response.ts\";\nexport { createRequestStateFromNative } from \"./globals/request.ts\";\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAA2B,IAA3B;AAkBO,IAHP;AAOO,IAHP;AAI6C,IAA7C;",
+  "debugId": "1A00B620C92685AE64756E2164756E21",
+  "names": []
+}

package/dist/cjs/package.json

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

package/dist/mjs/index.mjs

@@ -0,0 +1,22 @@
+// @bun
+// packages/fetch/src/index.ts
+import { setupFetch } from "./setup.ts";
+import {
+  createHeadersStateFromNative,
+  headersStateToNative
+} from "./globals/headers.ts";
+import {
+  responseStateToNative,
+  createResponseStateFromNative
+} from "./globals/response.ts";
+import { createRequestStateFromNative } from "./globals/request.ts";
+export {
+  setupFetch,
+  responseStateToNative,
+  headersStateToNative,
+  createResponseStateFromNative,
+  createRequestStateFromNative,
+  createHeadersStateFromNative
+};
+
+//# debugId=DCC271F8F4EC31DA64756E2164756E21

package/dist/mjs/index.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": [
+    "export { setupFetch } from \"./setup.ts\";\n\nexport type {\n  SetupFetchOptions,\n  FetchHandle,\n  WebSocketData,\n  UpgradeRequest,\n  WebSocketCommand,\n  WebSocketOutgoingMessage,\n  WebSocketClose,\n  ServeState,\n  ServerWebSocketState,\n} from \"./types.ts\";\n\n// Re-export utilities that might be useful\nexport {\n  createHeadersStateFromNative,\n  headersStateToNative,\n} from \"./globals/headers.ts\";\nexport {\n  responseStateToNative,\n  createResponseStateFromNative,\n} from \"./globals/response.ts\";\nexport { createRequestStateFromNative } from \"./globals/request.ts\";\n"
+  ],
+  "mappings": ";;AAAA;AAeA;AAAA;AAAA;AAAA;AAIA;AAAA;AAAA;AAAA;AAIA;",
+  "debugId": "DCC271F8F4EC31DA64756E2164756E21",
+  "names": []
+}

package/dist/mjs/package.json

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

package/dist/types/globals/abort-controller.d.ts

@@ -0,0 +1,9 @@
+import type { QuickJSContext } from "quickjs-emscripten";
+/**
+ * Setup AbortController and AbortSignal classes in QuickJS.
+ * Uses pure QuickJS implementation so that:
+ * - controller.signal returns an actual AbortSignal instance
+ * - Event listeners work correctly
+ * - All prototype methods are accessible
+ */
+export declare function setupAbortControllerAndSignal(context: QuickJSContext): void;

package/dist/types/globals/fetch.d.ts

@@ -0,0 +1,5 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+/**
+ * Create the fetch function for QuickJS
+ */
+export declare function createFetchFunction(context: QuickJSContext, onFetch?: (request: Request) => Promise<Response>): QuickJSHandle;

package/dist/types/globals/form-data.d.ts

@@ -0,0 +1,37 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap } from "@ricsam/quickjs-core";
+/**
+ * Internal state for FormData entries
+ * Each entry can have multiple values (same key appended multiple times)
+ */
+export interface FormDataEntry {
+    name: string;
+    value: string | FormDataFileValue;
+}
+export interface FormDataFileValue {
+    data: Uint8Array;
+    filename: string;
+    type: string;
+}
+export interface FormDataState {
+    entries: FormDataEntry[];
+}
+/**
+ * Create the FormData class for QuickJS
+ */
+export declare function createFormDataClass(context: QuickJSContext, stateMap: StateMap): QuickJSHandle;
+/**
+ * Parse multipart/form-data body
+ */
+export declare function parseMultipartFormData(body: Uint8Array, contentType: string): FormDataState;
+/**
+ * Parse URL-encoded form data
+ */
+export declare function parseUrlEncodedFormData(body: Uint8Array): FormDataState;
+/**
+ * Serialize FormData to multipart/form-data format
+ */
+export declare function serializeFormData(state: FormDataState): {
+    body: Uint8Array;
+    contentType: string;
+};

package/dist/types/globals/headers.d.ts

@@ -0,0 +1,36 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap } from "@ricsam/quickjs-core";
+import type { HeadersState } from "../types.ts";
+/**
+ * Create the Headers class for QuickJS
+ */
+export declare function createHeadersClass(context: QuickJSContext, stateMap: StateMap): QuickJSHandle;
+/**
+ * Create a HeadersState from a native Headers object
+ */
+export declare function createHeadersStateFromNative(headers: Headers): HeadersState;
+/**
+ * Convert HeadersState to native Headers
+ */
+export declare function headersStateToNative(state: HeadersState): Headers;
+/**
+ * Interface for a Headers-like object that can be returned from getters
+ */
+export interface HeadersLike {
+    headers: Map<string, string[]>;
+    append(name: string, value: string): void;
+    delete(name: string): void;
+    get(name: string): string | null;
+    has(name: string): boolean;
+    set(name: string, value: string): void;
+    entries(): Array<[string, string]>;
+    keys(): string[];
+    values(): string[];
+    forEach(callback: (value: string, key: string) => void): void;
+    getSetCookie(): string[];
+}
+/**
+ * Create a Headers-like object from HeadersState that has all the Headers methods
+ * This is used for getters that need to return an object with Headers API
+ */
+export declare function createHeadersLike(state: HeadersState): HeadersLike;

package/dist/types/globals/request.d.ts

@@ -0,0 +1,16 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap } from "@ricsam/quickjs-core";
+import type { RequestState } from "../types.ts";
+/**
+ * Type for the stream factory function
+ */
+type StreamFactory = (source: UnderlyingSource) => QuickJSHandle;
+/**
+ * Create the Request class for QuickJS
+ */
+export declare function createRequestClass(context: QuickJSContext, stateMap: StateMap, createStream?: StreamFactory): QuickJSHandle;
+/**
+ * Create a RequestState from a native Request object
+ */
+export declare function createRequestStateFromNative(request: Request): Promise<RequestState>;
+export {};

package/dist/types/globals/response.d.ts

@@ -0,0 +1,25 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap } from "@ricsam/quickjs-core";
+import type { ResponseState } from "../types.ts";
+/**
+ * Type for the stream factory function
+ */
+type StreamFactory = (source: UnderlyingSource) => QuickJSHandle;
+/**
+ * Create the Response class for QuickJS
+ */
+export declare function createResponseClass(context: QuickJSContext, stateMap: StateMap, createStream?: StreamFactory): QuickJSHandle;
+/**
+ * Add static methods to Response class after it's been set on global
+ * This must be called after Response and Headers are available on global
+ */
+export declare function addResponseStaticMethods(context: QuickJSContext): void;
+/**
+ * Convert ResponseState (or unmarshalled Response object) to native Response
+ */
+export declare function responseStateToNative(state: ResponseState | Record<string, unknown>): Response;
+/**
+ * Create a ResponseState from a native Response
+ */
+export declare function createResponseStateFromNative(response: Response): Promise<ResponseState>;
+export {};

package/dist/types/globals/serve.d.ts

@@ -0,0 +1,16 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap } from "@ricsam/quickjs-core";
+import type { ServeState, WebSocketCommand } from "../types.ts";
+/**
+ * Create the ServerWebSocket class for QuickJS
+ */
+export declare function createServerWebSocketClass(context: QuickJSContext, stateMap: StateMap, onWebSocketCommand: (cmd: WebSocketCommand) => void): QuickJSHandle;
+/**
+ * Create the Server class for QuickJS
+ */
+export declare function createServerClass(context: QuickJSContext, stateMap: StateMap, serveState: ServeState): QuickJSHandle;
+/**
+ * Create the serve function for QuickJS
+ * Uses context.newFunction instead of defineFunction to properly manage handle lifetimes
+ */
+export declare function createServeFunction(context: QuickJSContext, stateMap: StateMap, serveState: ServeState): QuickJSHandle;

package/dist/types/handle.d.ts

@@ -0,0 +1,6 @@
+import type { QuickJSContext } from "quickjs-emscripten";
+import type { StateMap, FetchHandle, ServeState } from "./types.ts";
+/**
+ * Create the FetchHandle implementation
+ */
+export declare function createFetchHandle(context: QuickJSContext, stateMap: StateMap, serveState: ServeState): FetchHandle;

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export { setupFetch } from "./setup.ts";
+export type { SetupFetchOptions, FetchHandle, WebSocketData, UpgradeRequest, WebSocketCommand, WebSocketOutgoingMessage, WebSocketClose, ServeState, ServerWebSocketState, } from "./types.ts";
+export { createHeadersStateFromNative, headersStateToNative, } from "./globals/headers.ts";
+export { responseStateToNative, createResponseStateFromNative, } from "./globals/response.ts";
+export { createRequestStateFromNative } from "./globals/request.ts";

package/dist/types/setup.d.ts

@@ -0,0 +1,48 @@
+import type { QuickJSContext } from "quickjs-emscripten";
+import type { SetupFetchOptions, FetchHandle } from "./types.ts";
+/**
+ * Setup Fetch API in a QuickJS context
+ *
+ * Injects the following globals:
+ * - fetch
+ * - Request
+ * - Response
+ * - Headers
+ * - AbortController
+ * - AbortSignal
+ * - serve
+ * - FormData
+ *
+ * Also sets up Core APIs (Streams, Blob, File) if not already present.
+ *
+ * **Private globals (internal use):**
+ * - `__Server__` - Server class for serve() handler, instantiated via evalCode
+ * - `__ServerWebSocket__` - WebSocket class for connection handling
+ * - `__scheduleTimeout__` - Host function to schedule AbortSignal.timeout()
+ * - `__checkTimeout__` - Host function to check if timeout elapsed
+ *
+ * These private globals follow the `__Name__` convention and are required for
+ * JavaScript code in QuickJS to create class instances via evalCode.
+ * See PATTERNS.md section 5 for details.
+ *
+ * @example
+ * const handle = setupFetch(context, {
+ *   onFetch: async (request) => {
+ *     // Proxy to real fetch
+ *     return fetch(request);
+ *   }
+ * });
+ *
+ * context.evalCode(`
+ *   serve({
+ *     fetch(request, server) {
+ *       return new Response("Hello!");
+ *     }
+ *   });
+ * `);
+ *
+ * const response = await handle.dispatchRequest(
+ *   new Request("http://localhost/")
+ * );
+ */
+export declare function setupFetch(context: QuickJSContext, options?: SetupFetchOptions): FetchHandle;

package/dist/types/types.d.ts

@@ -0,0 +1,175 @@
+import type { QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap, CoreHandle } from "@ricsam/quickjs-core";
+export type { StateMap, CoreHandle };
+/**
+ * Options for setting up Fetch APIs
+ */
+export interface SetupFetchOptions {
+    /**
+     * Handler for outbound fetch() calls from QuickJS
+     * If not provided, fetch() will throw an error
+     */
+    onFetch?: (request: Request) => Promise<Response>;
+    /** Existing state map (creates new one if not provided) */
+    stateMap?: StateMap;
+    /** Existing core handle (sets up core if not provided) */
+    coreHandle?: CoreHandle;
+}
+/**
+ * Data associated with a WebSocket connection
+ */
+export interface WebSocketData {
+    /** User-provided data from server.upgrade() */
+    data: unknown;
+    /** Connection ID assigned by the host */
+    connectionId: string;
+}
+/**
+ * Pending upgrade request info
+ */
+export interface UpgradeRequest {
+    /** Whether an upgrade was requested */
+    requested: true;
+    /** User data passed to server.upgrade() */
+    data: unknown;
+}
+/**
+ * Message to send to a WebSocket
+ */
+export interface WebSocketOutgoingMessage {
+    type: "message";
+    connectionId: string;
+    data: string | ArrayBuffer;
+}
+/**
+ * Close command for a WebSocket
+ */
+export interface WebSocketClose {
+    type: "close";
+    connectionId: string;
+    code?: number;
+    reason?: string;
+}
+export type WebSocketCommand = WebSocketOutgoingMessage | WebSocketClose;
+/**
+ * Internal state for serve() handler
+ */
+export interface ServeState {
+    fetchHandler: QuickJSHandle | null;
+    websocketHandlers: {
+        open?: QuickJSHandle;
+        message?: QuickJSHandle;
+        close?: QuickJSHandle;
+        error?: QuickJSHandle;
+    };
+    pendingUpgrade: UpgradeRequest | null;
+    activeConnections: Map<string, ServerWebSocketState>;
+}
+export interface ServerWebSocketState {
+    data: unknown;
+    readyState: number;
+    connectionId: string;
+    wsHandle: QuickJSHandle | null;
+}
+/**
+ * Handle returned from setupFetch
+ */
+export interface FetchHandle {
+    /** State map containing all internal states */
+    readonly stateMap: StateMap;
+    /**
+     * Dispatch an HTTP request to the serve() handler
+     *
+     * @returns Response from the QuickJS handler
+     * @throws If no serve() handler is registered
+     */
+    dispatchRequest(request: Request): Promise<Response>;
+    /**
+     * Check if the last request resulted in an upgrade request
+     * Must be called immediately after dispatchRequest()
+     */
+    getUpgradeRequest(): UpgradeRequest | null;
+    /**
+     * Dispatch WebSocket open event
+     *
+     * @param connectionId Unique ID for this connection (host-assigned)
+     * @param data The data object from getUpgradeRequest()
+     */
+    dispatchWebSocketOpen(connectionId: string, data?: unknown): void;
+    /**
+     * Dispatch WebSocket message event
+     */
+    dispatchWebSocketMessage(connectionId: string, message: string | ArrayBuffer): void;
+    /**
+     * Dispatch WebSocket close event
+     */
+    dispatchWebSocketClose(connectionId: string, code: number, reason: string): void;
+    /**
+     * Dispatch WebSocket error event
+     */
+    dispatchWebSocketError(connectionId: string, error: Error): void;
+    /**
+     * Register a callback for outgoing WebSocket messages/commands
+     * Called when QuickJS code calls ws.send() or ws.close()
+     */
+    onWebSocketCommand(callback: (command: WebSocketCommand) => void): () => void;
+    /**
+     * Check if a serve() handler is registered
+     */
+    hasServeHandler(): boolean;
+    /**
+     * Dispose all handles and cleanup
+     */
+    dispose(): void;
+}
+export interface HeadersState {
+    headers: Map<string, string[]>;
+}
+export interface RequestState {
+    method: string;
+    url: string;
+    headersState: HeadersState;
+    body: Uint8Array | null;
+    bodyUsed: boolean;
+    cache: string;
+    credentials: string;
+    destination: string;
+    integrity: string;
+    keepalive: boolean;
+    mode: string;
+    redirect: string;
+    referrer: string;
+    referrerPolicy: string;
+    signal: AbortSignalState | null;
+}
+export interface ResponseState {
+    status: number;
+    statusText: string;
+    headersState: HeadersState;
+    body: Uint8Array | null;
+    bodyUsed: boolean;
+    url: string;
+    redirected: boolean;
+    type: string;
+    ok: boolean;
+}
+export interface AbortControllerState {
+    signalState: AbortSignalState;
+}
+export interface AbortSignalState {
+    aborted: boolean;
+    reason: unknown;
+    listeners: Set<() => void>;
+}
+export interface FormDataFileValue {
+    data: Uint8Array;
+    filename: string;
+    type: string;
+}
+export interface FormDataEntry {
+    name: string;
+    value: string | FormDataFileValue;
+}
+export interface FormDataState {
+    entries: FormDataEntry[];
+}

package/package.json

@@ -1,10 +1,55 @@
 {
   "name": "@ricsam/quickjs-fetch",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @ricsam/quickjs-fetch",
+  "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": {
+    "@ricsam/quickjs-core": "^0.2.0",
+    "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": "Fetch API implementation for QuickJS runtime",
+  "module": "./dist/mjs/index.mjs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
   ]
-}
+}