@b9g/platform 0.1.10 → 0.1.12

package/src/cookie-store.js

@@ -1,231 +0,0 @@
-/// <reference types="./cookie-store.d.ts" />
-// src/cookie-store.ts
-function parseCookieHeader(cookieHeader) {
-  const cookies = /* @__PURE__ */ new Map();
-  if (!cookieHeader)
-    return cookies;
-  const pairs = cookieHeader.split(/;\s*/);
-  for (const pair of pairs) {
-    const [name, ...valueParts] = pair.split("=");
-    if (name) {
-      const value = valueParts.join("=");
-      cookies.set(name.trim(), decodeURIComponent(value || ""));
-    }
-  }
-  return cookies;
-}
-function serializeCookie(cookie) {
-  let header = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(cookie.value)}`;
-  if (cookie.expires !== void 0 && cookie.expires !== null) {
-    const date = new Date(cookie.expires);
-    header += `; Expires=${date.toUTCString()}`;
-  }
-  if (cookie.domain) {
-    header += `; Domain=${cookie.domain}`;
-  }
-  if (cookie.path) {
-    header += `; Path=${cookie.path}`;
-  } else {
-    header += `; Path=/`;
-  }
-  if (cookie.sameSite) {
-    header += `; SameSite=${cookie.sameSite.charAt(0).toUpperCase() + cookie.sameSite.slice(1)}`;
-  } else {
-    header += `; SameSite=Strict`;
-  }
-  if (cookie.partitioned) {
-    header += `; Partitioned`;
-  }
-  header += `; Secure`;
-  return header;
-}
-function parseSetCookieHeader(setCookieHeader) {
-  const parts = setCookieHeader.split(/;\s*/);
-  const [nameValue, ...attributes] = parts;
-  const [name, ...valueParts] = nameValue.split("=");
-  const value = valueParts.join("=");
-  const cookie = {
-    name: decodeURIComponent(name.trim()),
-    value: decodeURIComponent(value || "")
-  };
-  for (const attr of attributes) {
-    const [key, ...attrValueParts] = attr.split("=");
-    const attrKey = key.trim().toLowerCase();
-    const attrValue = attrValueParts.join("=").trim();
-    switch (attrKey) {
-      case "expires":
-        cookie.expires = new Date(attrValue).getTime();
-        break;
-      case "max-age":
-        cookie.expires = Date.now() + parseInt(attrValue, 10) * 1e3;
-        break;
-      case "domain":
-        cookie.domain = attrValue;
-        break;
-      case "path":
-        cookie.path = attrValue;
-        break;
-      case "secure":
-        cookie.secure = true;
-        break;
-      case "samesite":
-        cookie.sameSite = attrValue.toLowerCase();
-        break;
-      case "partitioned":
-        cookie.partitioned = true;
-        break;
-    }
-  }
-  return cookie;
-}
-var RequestCookieStore = class extends EventTarget {
-  #cookies;
-  #changes;
-  // null = deleted
-  #request;
-  // Event handler for cookie changes (spec compliance)
-  // eslint-disable-next-line no-restricted-syntax
-  onchange = null;
-  constructor(request) {
-    super();
-    this.#cookies = /* @__PURE__ */ new Map();
-    this.#changes = /* @__PURE__ */ new Map();
-    this.#request = request || null;
-    if (request) {
-      const cookieHeader = request.headers.get("cookie");
-      if (cookieHeader) {
-        const parsed = parseCookieHeader(cookieHeader);
-        for (const [name, value] of parsed) {
-          this.#cookies.set(name, { name, value });
-        }
-      }
-    }
-  }
-  /**
-   * Get a single cookie by name
-   */
-  async get(nameOrOptions) {
-    const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions.name;
-    if (!name) {
-      throw new TypeError("Cookie name is required");
-    }
-    if (this.#changes.has(name)) {
-      const change = this.#changes.get(name);
-      if (change === null || change === void 0)
-        return null;
-      return {
-        name: change.name,
-        value: change.value,
-        domain: change.domain ?? void 0,
-        path: change.path,
-        expires: change.expires ?? void 0,
-        sameSite: change.sameSite,
-        partitioned: change.partitioned
-      };
-    }
-    return this.#cookies.get(name) || null;
-  }
-  /**
-   * Get all cookies matching the filter
-   */
-  async getAll(nameOrOptions) {
-    const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions?.name;
-    const result = [];
-    const allNames = /* @__PURE__ */ new Set([
-      ...this.#cookies.keys(),
-      ...this.#changes.keys()
-    ]);
-    for (const cookieName of allNames) {
-      if (name && cookieName !== name)
-        continue;
-      if (this.#changes.has(cookieName) && this.#changes.get(cookieName) === null) {
-        continue;
-      }
-      const cookie = await this.get(cookieName);
-      if (cookie) {
-        result.push(cookie);
-      }
-    }
-    return result;
-  }
-  /**
-   * Set a cookie
-   */
-  async set(nameOrOptions, value) {
-    let cookie;
-    if (typeof nameOrOptions === "string") {
-      if (value === void 0) {
-        throw new TypeError("Cookie value is required");
-      }
-      cookie = {
-        name: nameOrOptions,
-        value,
-        path: "/",
-        sameSite: "strict"
-      };
-    } else {
-      cookie = {
-        path: "/",
-        sameSite: "strict",
-        ...nameOrOptions
-      };
-    }
-    const size = cookie.name.length + cookie.value.length;
-    if (size > 4096) {
-      throw new TypeError(
-        `Cookie name+value too large: ${size} bytes (max 4096)`
-      );
-    }
-    this.#changes.set(cookie.name, cookie);
-  }
-  /**
-   * Delete a cookie
-   */
-  async delete(nameOrOptions) {
-    const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions.name;
-    if (!name) {
-      throw new TypeError("Cookie name is required");
-    }
-    this.#changes.set(name, null);
-  }
-  /**
-   * Get Set-Cookie headers for all changes
-   * This should be called when constructing the Response
-   */
-  getSetCookieHeaders() {
-    const headers = [];
-    for (const [name, change] of this.#changes) {
-      if (change === null) {
-        headers.push(
-          serializeCookie({
-            name,
-            value: "",
-            expires: 0,
-            path: "/"
-          })
-        );
-      } else {
-        headers.push(serializeCookie(change));
-      }
-    }
-    return headers;
-  }
-  /**
-   * Check if there are any pending changes
-   */
-  hasChanges() {
-    return this.#changes.size > 0;
-  }
-  /**
-   * Clear all pending changes (for testing/reset)
-   */
-  clearChanges() {
-    this.#changes.clear();
-  }
-};
-export {
-  RequestCookieStore,
-  parseCookieHeader,
-  parseSetCookieHeader,
-  serializeCookie
-};

package/src/single-threaded.d.ts

@@ -1,59 +0,0 @@
-/**
- * @b9g/platform/single-threaded - Single-threaded ServiceWorker runtime
- *
- * Runs ServiceWorker code directly in the main thread without spawning workers.
- * Used when workerCount === 1 for maximum performance (no postMessage overhead).
- */
-import { CustomBucketStorage } from "@b9g/filesystem";
-import { type ProcessedShovelConfig } from "./config.js";
-export interface SingleThreadedRuntimeOptions {
-    /** Base directory for bucket path resolution (entrypoint directory) - REQUIRED */
-    baseDir: string;
-    /** Optional pre-created cache storage (for sharing across reloads) */
-    cacheStorage?: CacheStorage;
-    /** Optional pre-created bucket storage */
-    bucketStorage?: CustomBucketStorage;
-    /** Shovel configuration for bucket/cache settings */
-    config?: ProcessedShovelConfig;
-}
-/**
- * Single-threaded ServiceWorker runtime
- *
- * Provides the same interface as ServiceWorkerPool but runs everything
- * in the main thread for zero postMessage overhead.
- */
-export declare class SingleThreadedRuntime {
-    #private;
-    constructor(options: SingleThreadedRuntimeOptions);
-    /**
-     * Initialize the runtime (install scope as globalThis.self)
-     */
-    init(): Promise<void>;
-    /**
-     * Load and run a ServiceWorker entrypoint
-     * @param entrypoint - Path to the new entrypoint (hashed filename for cache busting)
-     */
-    reloadWorkers(entrypoint: string): Promise<void>;
-    /**
-     * Load a ServiceWorker entrypoint for the first time
-     * @param entrypoint - Path to the entrypoint file (content-hashed filename)
-     */
-    loadEntrypoint(entrypoint: string): Promise<void>;
-    /**
-     * Handle an HTTP request
-     * This is the key method - direct call, no postMessage!
-     */
-    handleRequest(request: Request): Promise<Response>;
-    /**
-     * Graceful shutdown
-     */
-    terminate(): Promise<void>;
-    /**
-     * Get the number of workers (always 1 for single-threaded)
-     */
-    get workerCount(): number;
-    /**
-     * Check if ready to handle requests
-     */
-    get ready(): boolean;
-}

package/src/single-threaded.js

@@ -1,109 +0,0 @@
-/// <reference types="./single-threaded.d.ts" />
-// src/single-threaded.ts
-import { getLogger } from "@logtape/logtape";
-import { ShovelGlobalScope, ShovelServiceWorkerRegistration } from "./runtime.js";
-import { CustomBucketStorage } from "@b9g/filesystem";
-import { CustomCacheStorage } from "@b9g/cache";
-import {
-  configureLogging,
-  createBucketFactory,
-  createCacheFactory
-} from "./config.js";
-var logger = getLogger(["single-threaded"]);
-var SingleThreadedRuntime = class {
-  #registration;
-  #scope;
-  #ready;
-  #entrypoint;
-  #config;
-  constructor(options) {
-    this.#ready = false;
-    this.#config = options.config;
-    const cacheStorage = options.cacheStorage || new CustomCacheStorage(createCacheFactory({ config: options.config }));
-    const bucketStorage = options.bucketStorage || new CustomBucketStorage(
-      createBucketFactory({ baseDir: options.baseDir, config: options.config })
-    );
-    this.#registration = new ShovelServiceWorkerRegistration();
-    this.#scope = new ShovelGlobalScope({
-      registration: this.#registration,
-      caches: cacheStorage,
-      buckets: bucketStorage
-    });
-    logger.info("SingleThreadedRuntime created", { baseDir: options.baseDir });
-  }
-  /**
-   * Initialize the runtime (install scope as globalThis.self)
-   */
-  async init() {
-    if (this.#config?.logging) {
-      await configureLogging(this.#config.logging);
-    }
-    this.#scope.install();
-    logger.info("SingleThreadedRuntime initialized - scope installed");
-  }
-  /**
-   * Load and run a ServiceWorker entrypoint
-   * @param entrypoint - Path to the new entrypoint (hashed filename for cache busting)
-   */
-  async reloadWorkers(entrypoint) {
-    logger.info("Reloading ServiceWorker", {
-      oldEntrypoint: this.#entrypoint,
-      newEntrypoint: entrypoint
-    });
-    this.#entrypoint = entrypoint;
-    this.#registration._serviceWorker._setState("parsed");
-    this.#ready = false;
-    await import(entrypoint);
-    await this.#registration.install();
-    await this.#registration.activate();
-    this.#ready = true;
-    logger.info("ServiceWorker loaded and activated", { entrypoint });
-  }
-  /**
-   * Load a ServiceWorker entrypoint for the first time
-   * @param entrypoint - Path to the entrypoint file (content-hashed filename)
-   */
-  async loadEntrypoint(entrypoint) {
-    this.#entrypoint = entrypoint;
-    logger.info("Loading ServiceWorker entrypoint", { entrypoint });
-    await import(entrypoint);
-    await this.#registration.install();
-    await this.#registration.activate();
-    this.#ready = true;
-    logger.info("ServiceWorker loaded and activated", { entrypoint });
-  }
-  /**
-   * Handle an HTTP request
-   * This is the key method - direct call, no postMessage!
-   */
-  async handleRequest(request) {
-    if (!this.#ready) {
-      throw new Error(
-        "SingleThreadedRuntime not ready - ServiceWorker not loaded"
-      );
-    }
-    return this.#registration.handleRequest(request);
-  }
-  /**
-   * Graceful shutdown
-   */
-  async terminate() {
-    this.#ready = false;
-    logger.info("SingleThreadedRuntime terminated");
-  }
-  /**
-   * Get the number of workers (always 1 for single-threaded)
-   */
-  get workerCount() {
-    return 1;
-  }
-  /**
-   * Check if ready to handle requests
-   */
-  get ready() {
-    return this.#ready;
-  }
-};
-export {
-  SingleThreadedRuntime
-};

package/src/worker-pool.d.ts

@@ -1,93 +0,0 @@
-/**
- * @b9g/platform/worker-pool - ServiceWorker pool implementation
- *
- * Manages a pool of workers that run the ServiceWorker runtime.
- * Handles worker lifecycle, message passing, and request routing.
- */
-export interface WorkerPoolOptions {
-    /** Number of workers in the pool (default: 1) */
-    workerCount?: number;
-    /** Request timeout in milliseconds (default: 30000) */
-    requestTimeout?: number;
-    /** Working directory for file resolution */
-    cwd?: string;
-}
-export interface WorkerMessage {
-    type: string;
-    [key: string]: any;
-}
-export interface WorkerRequest extends WorkerMessage {
-    type: "request";
-    request: {
-        url: string;
-        method: string;
-        headers: Record<string, string>;
-        body?: ArrayBuffer | null;
-    };
-    requestID: number;
-}
-export interface WorkerResponse extends WorkerMessage {
-    type: "response";
-    response: {
-        status: number;
-        statusText: string;
-        headers: Record<string, string>;
-        body: ArrayBuffer;
-    };
-    requestID: number;
-}
-export interface WorkerLoadMessage extends WorkerMessage {
-    type: "load";
-    entrypoint: string;
-}
-export interface WorkerReadyMessage extends WorkerMessage {
-    type: "ready" | "worker-ready";
-    entrypoint?: string;
-}
-export interface WorkerErrorMessage extends WorkerMessage {
-    type: "error";
-    error: string;
-    stack?: string;
-    requestID?: number;
-}
-export interface WorkerInitMessage extends WorkerMessage {
-    type: "init";
-    config: any;
-    baseDir: string;
-}
-export interface WorkerInitializedMessage extends WorkerMessage {
-    type: "initialized";
-}
-/**
- * ServiceWorkerPool - manages a pool of ServiceWorker instances
- * Handles HTTP request/response routing, cache coordination, and hot reloading
- */
-export declare class ServiceWorkerPool {
-    #private;
-    constructor(options?: WorkerPoolOptions, appEntrypoint?: string, cacheStorage?: CacheStorage, config?: any);
-    /**
-     * Initialize workers (must be called after construction)
-     */
-    init(): Promise<void>;
-    /**
-     * Handle HTTP request using round-robin worker selection
-     */
-    handleRequest(request: Request): Promise<Response>;
-    /**
-     * Reload ServiceWorker with new entrypoint (hot reload)
-     * The entrypoint path contains a content hash for cache busting
-     */
-    reloadWorkers(entrypoint: string): Promise<void>;
-    /**
-     * Graceful shutdown of all workers
-     */
-    terminate(): Promise<void>;
-    /**
-     * Get the number of active workers
-     */
-    get workerCount(): number;
-    /**
-     * Check if the pool is ready to handle requests
-     */
-    get ready(): boolean;
-}