@atolljs/core 0.1.6 → 0.1.8

package/README.md

@@ -68,7 +68,7 @@ export const counter = connectWorker<CounterWorker>({
   // Inline new Worker(new URL(..., import.meta.url)) — every bundler's
   // worker transform can see the entry point this way.
   worker: () => new Worker(new URL('./counter.worker.ts', import.meta.url), { type: 'module' }),
-  poolSize: 'auto',   // navigator.hardwareConcurrency, or pass a number
+  workers: 'auto',    // navigator.hardwareConcurrency; default 1 (one worker, no pool)
 });
 // counter.increment(1) → Promise<number>. The pool spawns on first call
 // (SSR-safe to import); counter.terminate() tears it down.

package/dist/contract/memoryDevtools.d.ts

@@ -0,0 +1,30 @@
+import type { Connector, SharedMemory } from './sharedMemory.js';
+export type WatchRule = {
+    text: string;
+    test: (value: unknown) => boolean;
+};
+interface WatchState {
+    rule: WatchRule;
+    /** Per contract: last version checked and last value preview ('change'). */
+    seen: WeakMap<SharedMemory<any>, {
+        version: number;
+        preview: string;
+    }>;
+    stop: () => void;
+    hits: number;
+}
+/** path → watch. Read by the write path — keep `.size` the only hot check. */
+export declare const memoryWatches: Map<string, WatchState>;
+/** Bounded preview of a field's current value — lists/typed arrays read only a head. */
+export declare const fieldPreview: (connector: Connector<any>) => string;
+/**
+ * Parse a watch rule: 'change' | '> n' | '< n' | '>= n' | '<= n' | '== v' |
+ * '!= v'. `v` is JSON when it parses ('"down"', 'true', '3'), else a bare
+ * string. Numeric comparisons only match number/bigint fields.
+ */
+export declare const parseWatchRule: (raw: string) => WatchRule;
+/** Write-path hook — only called when `memoryWatches.size > 0`. */
+export declare const checkWatchOnWrite: (memory: SharedMemory<any>, path: string, version: number) => void;
+/** Register the `memory.*` commands once; `contracts` lists every defined contract. */
+export declare const ensureMemoryCommands: (contracts: () => readonly SharedMemory<any>[]) => void;
+export {};

package/dist/contract/sharedMemory.d.ts

@@ -49,6 +49,8 @@ export interface ConnectorContext {
         view: Int32Array;
         index: number;
     };
+    /** The field's contract path — for devtools write events on granular commits. */
+    path?: string;
 }
 /**
  * A connector factory builds a connector for one field kind over a region of
@@ -79,6 +81,8 @@ export interface Connector<T> {
         view: Int32Array;
         index: number;
     };
+    /** Internal: the field's contract path — devtools node labels. */
+    readonly _path?: string;
 }
 export type ScalarKind = 'i8' | 'u8' | 'i16' | 'u16' | 'i32' | 'u32' | 'f32' | 'f64' | 'i64' | 'u64';
 /** A fixed-layout member spec: a scalar kind, `{ string: n }` for an inline UTF-8 field of n bytes, or `{ bool: true }` for a flag byte. */
@@ -316,8 +320,8 @@ export declare class SharedMemory<S extends SharedSpec = SharedSpec> {
         byteLength: number;
     }[];
     /**
-     * Fires when the contract is bound on this thread — immediately if already
-     * bound. Returns an unsubscribe function.
+     * Fires when the contract is bound on this thread — on every bind, and
+     * immediately if already bound. Returns an unsubscribe function.
      */
     onBound(cb: () => void): () => void;
     /** Typed lookup for flat (ungrouped) field keys. */

package/dist/contract/types.d.ts

@@ -52,6 +52,17 @@ export interface WorkerPoolConfig<S extends SharedSpec = SharedSpec, T extends T
      * skipped and workers receive a plain `{ type: 'INIT' }` handshake.
      */
     sharedMemory?: SharedMemory<S> & Prettify<SharedAccess<S>>;
+    /**
+     * Hand an existing SharedArrayBuffer to every spawned worker instead of
+     * allocating a fresh `WebAssembly.Memory` — the worker-shell case: a worker
+     * already bound to a contract spawns sub-workers on the SAME buffer
+     * (`sharedBuffer: contract.buffer`), or a second pool shares the first
+     * pool's `pool.sharedBuffer`. A thunk is resolved once, when the pool
+     * constructs. With `sharedMemory` the contract binds locally to this
+     * buffer; without it the buffer still ships via INIT_MEMORY and the
+     * workers bind their own defined contracts.
+     */
+    sharedBuffer?: SharedArrayBuffer | (() => SharedArrayBuffer | undefined);
     /**
      * Persistence adapter for `sharedMemory` — invoked with the contract right
      * after the pool binds it, and its `stop()` runs on `terminate()`.
@@ -60,6 +71,8 @@ export interface WorkerPoolConfig<S extends SharedSpec = SharedSpec, T extends T
     persistence?: (memory: SharedMemory<S>) => MemoryPersistence | undefined;
     /** Worker count — a number, or 'auto' (the default) for navigator.hardwareConcurrency ?? 4. */
     poolSize?: number | 'auto';
+    /** Display label for devtools/dashboards — falls back to a generated id. */
+    name?: string;
     memory?: MemoryConfig;
     /** Max in-flight tasks per worker (default 1); excess tasks queue FIFO. */
     concurrency?: number;

package/dist/devtools.d.ts

@@ -0,0 +1,346 @@
+/**
+ * Structured instrumentation events for the devtools/dashboard tooling.
+ * Same zero-cost contract as `log.ts` and islands' `proxyMetrics`: when no
+ * sink is installed, emit() is a single branch — production pays nothing.
+ *
+ * Events are emitted on whichever thread they occur on. Worker-side events
+ * reach the main thread's sink by postMessage forwarding (`ATOLL_DEVTOOLS`
+ * on the task channel — the pool re-emits them), so one sink sees the whole
+ * app. See docs/plans/devtools-dashboard.md.
+ */
+export type DevtoolsThread = 'main' | 'worker';
+export type TaskSettleOutcome = 'ok' | 'error' | 'aborted' | 'timeout' | 'queue-full' | 'crashed';
+export type DevtoolsEvent = {
+    type: 'pool:init';
+    poolId: string;
+    /** Config `name`, when supplied — a display label, not the id. */
+    label?: string;
+    poolSize: number;
+    /** Per-worker in-flight cap; 0 for a dedicated worker (no queue, uncapped). */
+    concurrency: number;
+    memoryBytes?: number;
+    /**
+     * True for a single dedicated worker (`connectWorker({ workers: 1 })`,
+     * island clients): no pool, no queue. Same event vocabulary otherwise.
+     */
+    dedicated?: boolean;
+} | {
+    type: 'pool:terminate';
+    poolId: string;
+} | {
+    type: 'worker:spawn';
+    poolId: string;
+    slot: number;
+} | {
+    type: 'worker:error';
+    poolId: string;
+    slot: number;
+    message: string;
+} | {
+    type: 'worker:respawn';
+    poolId: string;
+    slot: number;
+} | {
+    type: 'task:enqueue';
+    poolId: string;
+    callId: number;
+    taskId: string;
+} | {
+    type: 'task:dispatch';
+    poolId: string;
+    callId: number;
+    taskId: string;
+    slot: number;
+    waitMs: number;
+    /** Estimated structured-clone size of the task args (`estimateCloneBytes`). */
+    argBytes?: number;
+} | {
+    type: 'task:settle';
+    poolId: string;
+    callId: number;
+    taskId: string;
+    outcome: TaskSettleOutcome;
+    /** dispatch→reply; absent for calls that never ran. */
+    runMs?: number;
+    error?: string;
+    /** Estimated structured-clone size of the result (`estimateCloneBytes`). */
+    resultBytes?: number;
+} | {
+    type: 'memory:bind';
+    /** Version-counter index → field path, for pairing memory:write. */
+    fields: [index: number, path: string][];
+    totalBytes: number;
+} | {
+    type: 'memory:write';
+    path: string;
+    version: number;
+} | {
+    /** A dashboard-set watchpoint matched on write (`memory.watch` command). */
+    type: 'memory:watch-hit';
+    path: string;
+    version: number;
+    /** Preview of the written value (`previewValue`). */
+    value: string;
+    /** The watch rule as set, e.g. '> 100', 'change', '== "down"'. */
+    rule: string;
+} | {
+    type: 'island:mount';
+    instance: string;
+    app: string;
+    pid: string;
+    /** The client pool driving this island — links the island to its worker. */
+    poolId?: string;
+    /** Renderer/framework tag supplied by the mounter — observability only. */
+    framework?: string;
+} | {
+    type: 'island:unmount';
+    instance: string;
+} | {
+    type: 'island:event';
+    instance: string;
+    name: string;
+    /** Preview of the emitted payload (`previewValue`). */
+    payload?: string;
+} | {
+    /** The props an island currently holds: sent on mount and every updateProps. */
+    type: 'island:props';
+    instance: string;
+    /** Preview of the props object (`previewValue`); callbacks show as '[fn]'. */
+    props: string;
+} | {
+    type: 'island:task';
+    instance: string;
+    /** The client call behind the round-trip — the island's "request". */
+    method: 'mount' | 'whoami' | 'dispatch' | 'setSize' | 'updateProps' | 'flush' | 'unmount';
+    /** Round-trip ms: call → ops returned (worker render + transport). */
+    ms: number;
+    /** Op count in the returned batch (response size in ops). */
+    ops?: number;
+    error?: string;
+} | {
+    type: 'island:ops';
+    instance: string;
+    /** The client call that produced the batch. */
+    via: 'mount' | 'updateProps' | 'dispatch' | 'setSize' | 'flush' | 'unmount';
+    count: number;
+    /** Main-thread replay time; worker-side render time rides call timings. */
+    replayMs?: number;
+    /** Estimated structured-clone size of the op batch (`estimateCloneBytes`). */
+    bytes?: number;
+} | {
+    type: 'net:fetch';
+    /** Per-context sequence — correlates the net:fetch-detail follow-up. */
+    id: number;
+    url: string;
+    method: string;
+    /** HTTP status — absent when the request failed before a response. */
+    status?: number;
+    /** Time from dispatch to response headers (error: to failure). */
+    ms: number;
+    /** Response Content-Length when advertised. */
+    bytes?: number;
+    error?: string;
+    reqHeaders?: [string, string][];
+    /** Capped preview; non-text bodies are described, not dumped. */
+    reqBody?: string;
+} | {
+    /**
+     * Detail follow-up to net:fetch (same id) — emitted after the response
+     * settles so it can carry headers, a capped body preview, and the
+     * Resource Timing stage breakdown once the entry exists.
+     */
+    type: 'net:fetch-detail';
+    id: number;
+    /** Present when the body was only readable async (Request objects). */
+    reqBody?: string;
+    resHeaders?: [string, string][];
+    resBody?: string;
+    /**
+     * Stage ms from PerformanceResourceTiming: queue (stalled → fetch
+     * start), dns, tcp, tls, wait (request → first byte), download.
+     * Absent for cross-origin responses without Timing-Allow-Origin.
+     */
+    timing?: {
+        queue: number;
+        dns: number;
+        tcp: number;
+        tls: number;
+        wait: number;
+        download: number;
+    };
+    transferSize?: number;
+    encodedSize?: number;
+    decodedSize?: number;
+} | {
+    type: 'runtime:memory';
+    /**
+     * measureUserAgentSpecificMemory: cluster total.
+     * performance.memory / process.memoryUsage fallback: this context's
+     * usedJSHeapSize / heapUsed.
+     */
+    heapBytes: number;
+    heapLimitBytes?: number;
+    /** Resident set size — present on the Node memoryUsage() path. */
+    rssBytes?: number;
+    /**
+     * Per-execution-context attribution from
+     * `performance.measureUserAgentSpecificMemory` — emitted on the main
+     * thread only (workers can't self-identify among same-URL contexts).
+     * Worker contexts are identified by their script URL.
+     */
+    contexts?: {
+        bytes: number;
+        scope?: string;
+        url?: string;
+    }[];
+} | {
+    /**
+     * A main-thread frame that blocked rendering: Long Animation Frame
+     * entries where supported, `longtask` entries as the fallback.
+     */
+    type: 'runtime:longframe';
+    /** Frame (or long task) duration. */
+    ms: number;
+    /** Time past the 50ms budget that blocked input/render. */
+    blockingMs: number;
+    /** LoAF script attribution, longest first (capped). */
+    scripts?: {
+        src?: string;
+        fn?: string;
+        ms: number;
+    }[];
+    /**
+     * Page was hidden: frame duration is throttling, not work, so only
+     * frames with substantial script time are reported. Excluded from
+     * foreground jank metrics.
+     */
+    hidden?: boolean;
+} | {
+    /** Main-thread frame rate, sampled once a second via rAF while devtools is on. */
+    type: 'runtime:frames';
+    fps: number;
+    /** Frames over ~2× the display interval in that second. */
+    dropped: number;
+} | {
+    /** A `src/log.ts` entry, mirrored into the stream (worker logs forward too). */
+    type: 'log';
+    level: 'trace' | 'debug' | 'info' | 'warn' | 'error';
+    scope: string;
+    message: string;
+    /** Preview of the structured data (`previewValue`). */
+    data?: string;
+} | {
+    /**
+     * Cross-thread reactivity edge/node update for the dependency graph.
+     * `id` names a reactive source or subscriber; `deps` are the ids it reads.
+     */
+    type: 'reactive:node';
+    id: string;
+    kind: 'source' | 'derived' | 'effect' | 'bridge';
+    label?: string;
+    deps?: string[];
+    /** Thread-qualified owner, e.g. a pool id or island instance. */
+    owner?: string;
+    /** Set when the node is disposed. */
+    disposed?: boolean;
+};
+export type EmittedDevtoolsEvent = DevtoolsEvent & {
+    /** performance.now() on the emitting thread. */
+    at: number;
+    /** Which side of the boundary emitted the event. */
+    thread: DevtoolsThread;
+    /**
+     * Stamped by the pool when re-emitting a worker-forwarded event —
+     * attributes worker-side events (memory writes, fetches, heap samples)
+     * to the specific pool slot that produced them.
+     */
+    worker?: {
+        poolId: string;
+        slot: number;
+    };
+};
+export type DevtoolsSink = (event: EmittedDevtoolsEvent) => void;
+/**
+ * Install the transport sink (devtools transports hook here); null removes
+ * it. Additive sinks (`addDevtoolsSink`) are unaffected.
+ */
+export declare const setDevtoolsSink: (custom: DevtoolsSink | null) => void;
+/**
+ * Add a listener alongside the transport sink (exporters like OTLP);
+ * returns its remover. Any installed listener turns `devtoolsEnabled()` on,
+ * so pools spawned afterwards enable worker forwarding the same way.
+ */
+export declare const addDevtoolsSink: (listener: DevtoolsSink) => (() => void);
+/** Emit a structured event — one branch when no sink is installed. */
+export declare const emitDevtools: (event: DevtoolsEvent) => void;
+/**
+ * Re-emit an already-stamped event — for forwarding worker-side events that
+ * arrived over postMessage without re-stamping their timing/thread.
+ */
+export declare const forwardDevtools: (event: EmittedDevtoolsEvent) => void;
+/** True when a devtools sink (transport or additive listener) is installed on this thread. */
+export declare const devtoolsEnabled: () => boolean;
+/**
+ * Compact, bounded preview of any value for event payloads: JSON-ish,
+ * functions as '[fn]', typed arrays/buffers described by size, cycles cut,
+ * capped at `max` chars. Call only behind `devtoolsEnabled()`.
+ */
+export declare const previewValue: (value: unknown, max?: number) => string;
+/**
+ * Rough structured-clone size in bytes: strings 2B/char, numbers 8B,
+ * typed arrays/buffers by byteLength, plus small per-key overhead. A cost
+ * signal for the dashboard ("is this message big?"), not an exact count.
+ * Walks at most `budget` nodes. Call only behind `devtoolsEnabled()`.
+ */
+export declare const estimateCloneBytes: (value: unknown, budget?: number) => number;
+/**
+ * A command the dashboard can invoke on this app (`control` frames on the
+ * devtools transport). Args and result must be structured-cloneable and
+ * JSON-safe (the WebSocket path stringifies them).
+ */
+export type DevtoolsCommandHandler = (args: Record<string, unknown>) => unknown | Promise<unknown>;
+/**
+ * Register a dashboard-invocable command; returns an unregister function.
+ * Names are dotted by area: 'island.tree', 'worker.kill', 'memory.read'.
+ * A later registration under the same name replaces the earlier one.
+ */
+export declare const registerDevtoolsCommand: (name: string, handler: DevtoolsCommandHandler) => (() => void);
+/** Names of the registered commands — the dashboard enables controls from this. */
+export declare const listDevtoolsCommands: () => string[];
+/** Run a registered command (transports call this for inbound `control` frames). */
+export declare const runDevtoolsCommand: (name: string, args?: Record<string, unknown>) => Promise<unknown>;
+/**
+ * Worker side: route emitted events to the main thread over the task
+ * channel (`ATOLL_DEVTOOLS` messages — the pool re-emits them into its
+ * sink). Switched on by the pool's INIT handshake when the pool has a
+ * sink installed, so workers only forward when someone is listening.
+ */
+export declare const enableWorkerDevtoolsForwarding: () => void;
+/**
+ * Wrap `scope.fetch` to emit `net:fetch` (+ a `net:fetch-detail` follow-up
+ * with headers/body previews and stage timings) for every request — covers
+ * main thread (installed by connectDevtools) and workers (installed by the
+ * INIT handshake's forwarding flag). Idempotent; restores nothing (the
+ * wrapper delegates to the captured original). XHR is not covered.
+ */
+export declare const installFetchProbe: (scope: {
+    fetch?: typeof fetch;
+}) => void;
+/**
+ * Emit `runtime:memory` periodically — JS heap usage. On the main thread,
+ * prefers `performance.measureUserAgentSpecificMemory()`, which reports a
+ * per-execution-context breakdown (windows + workers identified by script
+ * URL) for the whole agent cluster; falls back to `performance.memory`,
+ * which also covers the worker-side install on engines that expose it
+ * there, then `process.memoryUsage()` on Node (heapUsed + rss — works
+ * inside worker_threads too). No-ops with none of the three.
+ */
+export declare const installMemoryProbe: (scope: object, intervalMs?: number) => void;
+/**
+ * Process-unique ids for runners. Unnamed: 'pool-1', 'worker-2', … Named:
+ * the slugged name plus a kind suffix, '-p' for a pool and '-w' for a
+ * dedicated worker ('regions-p', 'ops-inline-w'); a repeated name gets a
+ * counter ('regions-w', 'regions-w2'). Slugs never contain '#', '~' or
+ * '|', which the dashboard uses to qualify forwarded ids.
+ */
+export declare const nextDevtoolsId: (prefix: string, name?: string) => string;

package/dist/index.d.ts

@@ -11,8 +11,12 @@ export { MemoryManager } from './pool/memory.js';
 export { WorkerPool } from './pool/workerPool.js';
 export type { PoolStats, RunOptions } from './pool/workerPool.js';
 export { PoolQueueFullError, TaskAbortedError, TaskTimeoutError, WorkerCrashedError, } from './pool/errors.js';
-export { connectWorker, workerClient } from './pool/workerClient.js';
-export type { ClientMethods, ConnectWorkerConfig, WorkerClient, WorkerMethods, } from './pool/workerClient.js';
+export { DedicatedWorker } from './pool/dedicatedWorker.js';
+export type { DedicatedWorkerConfig } from './pool/dedicatedWorker.js';
+export { connectWorker, resolveWorkerCount, workerClient } from './pool/workerClient.js';
+export type { ClientMethods, ConnectWorkerConfig, WorkerClient, WorkerMethods, WorkerRunner, } from './pool/workerClient.js';
+export { connectSubWorker } from './pool/subWorkerClient.js';
+export type { ConnectSubWorkerConfig } from './pool/subWorkerClient.js';
 export { connectSharedWorker } from './shared/sharedWorkerClient.js';
 export type { SharedWorkerClient } from './shared/sharedWorkerClient.js';
 export { sharedWorkerHost } from './shared/sharedWorkerHost.js';
@@ -29,3 +33,5 @@ export { defineTask, isAsyncTask, toTask } from './task.js';
 export type { AsyncTask, TaskSnapshot } from './task.js';
 export { getLogLevel, log, scoped, setLogLevel, setLogSink } from './log.js';
 export type { LogEntry, LogLevel, LogSink } from './log.js';
+export { addDevtoolsSink, devtoolsEnabled, emitDevtools, estimateCloneBytes, installFetchProbe, installMemoryProbe, listDevtoolsCommands, previewValue, registerDevtoolsCommand, runDevtoolsCommand, setDevtoolsSink, } from './devtools.js';
+export type { DevtoolsCommandHandler, DevtoolsEvent, DevtoolsSink, DevtoolsThread, EmittedDevtoolsEvent, TaskSettleOutcome, } from './devtools.js';

package/dist/index.js

@@ -1,19 +1,22 @@
 import { msgpackrCodec as e } from "./index2.js";
 import { SchemaError as t, z as n } from "./index3.js";
 import { listSchema as r } from "./index4.js";
-import { getLogLevel as i, log as a, scoped as o, setLogLevel as s, setLogSink as c } from "./index5.js";
-import { bindSharedMemories as l, defineSharedMemory as u, field as d, getDefinedSharedMemoryCount as f, jsonCodec as p, registerConnectorFactory as m } from "./index6.js";
-import { reef as h } from "./index7.js";
-import { MemoryManager as g } from "./index8.js";
-import { PoolQueueFullError as _, TaskAbortedError as v, TaskTimeoutError as y, WorkerCrashedError as b } from "./index9.js";
-import { WorkerPool as x } from "./index10.js";
-import { connectWorker as S, workerClient as C } from "./index11.js";
-import { connectSharedWorker as w } from "./index12.js";
-import { TaskRegistry as T } from "./index13.js";
-import { sharedWorkerHost as E } from "./index14.js";
-import { createClient as D, defineService as O, implementService as k, rpc as A, serviceMethod as j } from "./index15.js";
-import { RESERVED_CLIENT_KEYS as M, defineWorker as N } from "./index17.js";
-import { reactive as P, shallowEqual as F, watch as I } from "./index18.js";
-import { observe as L } from "./index19.js";
-import { defineTask as R, isAsyncTask as z, toTask as B } from "./index20.js";
-export { g as MemoryManager, _ as PoolQueueFullError, M as RESERVED_CLIENT_KEYS, t as SchemaError, v as TaskAbortedError, T as TaskRegistry, y as TaskTimeoutError, b as WorkerCrashedError, x as WorkerPool, l as bindSharedMemories, w as connectSharedWorker, S as connectWorker, D as createClient, O as defineService, u as defineSharedMemory, R as defineTask, N as defineWorker, d as field, f as getDefinedSharedMemoryCount, i as getLogLevel, k as implementService, z as isAsyncTask, p as jsonCodec, r as listSchema, a as log, e as msgpackrCodec, L as observe, P as reactive, h as reef, m as registerConnectorFactory, A as rpc, o as scoped, j as serviceMethod, s as setLogLevel, c as setLogSink, F as shallowEqual, E as sharedWorkerHost, B as toTask, I as watch, C as workerClient, n as z };
+import { addDevtoolsSink as i, devtoolsEnabled as a, emitDevtools as o, estimateCloneBytes as s, installFetchProbe as c, installMemoryProbe as l, listDevtoolsCommands as u, previewValue as d, registerDevtoolsCommand as f, runDevtoolsCommand as p, setDevtoolsSink as m } from "./index5.js";
+import { getLogLevel as h, log as g, scoped as _, setLogLevel as v, setLogSink as y } from "./index7.js";
+import { bindSharedMemories as b, defineSharedMemory as x, field as S, getDefinedSharedMemoryCount as C, jsonCodec as w, registerConnectorFactory as T } from "./index8.js";
+import { reef as E } from "./index9.js";
+import { MemoryManager as D } from "./index10.js";
+import { PoolQueueFullError as O, TaskAbortedError as k, TaskTimeoutError as A, WorkerCrashedError as j } from "./index11.js";
+import { WorkerPool as M } from "./index15.js";
+import { DedicatedWorker as N } from "./index16.js";
+import { connectWorker as P, resolveWorkerCount as F, workerClient as I } from "./index17.js";
+import { connectSubWorker as L } from "./index18.js";
+import { connectSharedWorker as R } from "./index19.js";
+import { TaskRegistry as z } from "./index20.js";
+import { sharedWorkerHost as B } from "./index21.js";
+import { createClient as V, defineService as H, implementService as U, rpc as W, serviceMethod as G } from "./index22.js";
+import { RESERVED_CLIENT_KEYS as K, defineWorker as q } from "./index24.js";
+import { reactive as J, shallowEqual as Y, watch as X } from "./index26.js";
+import { observe as Z } from "./index27.js";
+import { defineTask as Q, isAsyncTask as $, toTask as ee } from "./index28.js";
+export { N as DedicatedWorker, D as MemoryManager, O as PoolQueueFullError, K as RESERVED_CLIENT_KEYS, t as SchemaError, k as TaskAbortedError, z as TaskRegistry, A as TaskTimeoutError, j as WorkerCrashedError, M as WorkerPool, i as addDevtoolsSink, b as bindSharedMemories, R as connectSharedWorker, L as connectSubWorker, P as connectWorker, V as createClient, H as defineService, x as defineSharedMemory, Q as defineTask, q as defineWorker, a as devtoolsEnabled, o as emitDevtools, s as estimateCloneBytes, S as field, C as getDefinedSharedMemoryCount, h as getLogLevel, U as implementService, c as installFetchProbe, l as installMemoryProbe, $ as isAsyncTask, w as jsonCodec, u as listDevtoolsCommands, r as listSchema, g as log, e as msgpackrCodec, Z as observe, d as previewValue, J as reactive, E as reef, T as registerConnectorFactory, f as registerDevtoolsCommand, F as resolveWorkerCount, W as rpc, p as runDevtoolsCommand, _ as scoped, G as serviceMethod, m as setDevtoolsSink, v as setLogLevel, y as setLogSink, Y as shallowEqual, B as sharedWorkerHost, ee as toTask, X as watch, I as workerClient, n as z };