@atolljs/core 0.1.5 → 0.1.7

package/dist/contract/reef.d.ts

@@ -24,7 +24,7 @@ import { z } from './zod.js';
  * `_zod.def`, so `reef.object({ id: z.uint32() })` mixes freely.
  */
 export declare const reef: {
-    i8: () => import("./zod.js").Fluent<{
+    i8: () => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
@@ -43,8 +43,8 @@ export declare const reef: {
         };
         check(...checks: import("./zod.js").Check[]): /*elided*/ any;
         register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): /*elided*/ any;
-    }>;
-    u8: () => import("./zod.js").Fluent<{
+    }>>;
+    u8: () => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
@@ -63,8 +63,8 @@ export declare const reef: {
         };
         check(...checks: import("./zod.js").Check[]): any;
         register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
-    }>;
-    i16: () => import("./zod.js").Fluent<{
+    }>>;
+    i16: () => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
@@ -83,8 +83,8 @@ export declare const reef: {
         };
         check(...checks: import("./zod.js").Check[]): any;
         register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
-    }>;
-    u16: () => import("./zod.js").Fluent<{
+    }>>;
+    u16: () => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
@@ -103,7 +103,7 @@ export declare const reef: {
         };
         check(...checks: import("./zod.js").Check[]): any;
         register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
-    }>;
+    }>>;
     i32: () => import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
@@ -225,7 +225,7 @@ export declare const reef: {
         register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
     }>;
     /** Bounded int — compiles to the narrowest covering kind (0..3 → u8). */
-    int: (min: number, max: number) => import("./zod.js").Fluent<{
+    int: (min: number, max: number) => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
@@ -244,9 +244,9 @@ export declare const reef: {
         };
         check(...checks: import("./zod.js").Check[]): /*elided*/ any;
         register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): /*elided*/ any;
-    }>;
+    }>>;
     /** A flag byte — reads and writes as boolean. */
-    boolean: () => import("./zod.js").Fluent<{
+    boolean: () => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: boolean;
             input: boolean;
@@ -265,11 +265,11 @@ export declare const reef: {
         };
         check(...checks: import("./zod.js").Check[]): /*elided*/ any;
         register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): /*elided*/ any;
-    }>;
+    }>>;
     /** Fixed-capacity inline UTF-8 string — `bytes` is the byte budget. The
      *  schema itself refuses over-budget values, so `.parse` and connector
      *  writes enforce the same limit. */
-    string: (bytes: number) => import("./zod.js").Fluent<{
+    string: (bytes: number) => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: string;
             input: string;
@@ -288,52 +288,112 @@ export declare const reef: {
         };
         check(...checks: import("./zod.js").Check[]): /*elided*/ any;
         register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): /*elided*/ any;
-    }>;
+    }>>;
     /** A fixed-layout record shape — every member must be a fixed-width schema. */
-    object: <S extends z.ZodRawShape>(shape: S) => import("./zod.js").Fluent<{
+    object: <S extends z.ZodRawShape>(shape: S) => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
-            output: { [K in keyof S]: S[K] extends {
+            output: { [K in keyof S as (S[K] extends {
+                _zod: {
+                    output: infer O;
+                };
+            } ? undefined extends O ? true : false : false) extends true ? never : K]: S[K] extends infer T_1 ? T_1 extends S[K] ? T_1 extends {
+                _zod: {
+                    output: infer O_1;
+                };
+            } ? O_1 : never : never : never; } & { [K in keyof S as (S[K] extends {
                 _zod: {
                     output: infer O;
                 };
-            } ? O : never; };
-            input: { [K in keyof S]: S[K] extends {
+            } ? undefined extends O ? true : false : false) extends true ? K : never]?: (S[K] extends infer T_1 ? T_1 extends S[K] ? T_1 extends {
+                _zod: {
+                    output: infer O_1;
+                };
+            } ? O : never : never : never) | undefined; } extends infer T ? { [K in keyof T]: T[K]; } : never;
+            input: { [K in keyof S as (S[K] extends {
                 _zod: {
                     output: infer O;
                 };
-            } ? O : never; };
+            } ? undefined extends O ? true : false : false) extends true ? never : K]: S[K] extends infer T_1 ? T_1 extends S[K] ? T_1 extends {
+                _zod: {
+                    output: infer O_1;
+                };
+            } ? O_1 : never : never : never; } & { [K in keyof S as (S[K] extends {
+                _zod: {
+                    output: infer O;
+                };
+            } ? undefined extends O ? true : false : false) extends true ? K : never]?: (S[K] extends infer T_1 ? T_1 extends S[K] ? T_1 extends {
+                _zod: {
+                    output: infer O_1;
+                };
+            } ? O : never : never : never) | undefined; } extends infer T ? { [K in keyof T]: T[K]; } : never;
             def: import("./zod.js").SchemaDef & {
                 type: 'object';
                 shape: S;
             };
         };
         get shape(): S;
-        inner(v: unknown): { [K in keyof S]: S[K] extends {
+        inner(v: unknown): { [K in keyof S as (S[K] extends {
+            _zod: {
+                output: infer O;
+            };
+        } ? undefined extends O ? true : false : false) extends true ? never : K]: S[K] extends infer T_1 ? T_1 extends S[K] ? T_1 extends {
+            _zod: {
+                output: infer O_1;
+            };
+        } ? O_1 : never : never : never; } & { [K in keyof S as (S[K] extends {
             _zod: {
                 output: infer O;
             };
-        } ? O : never; };
-        parse(value: unknown): { [K in keyof S]: S[K] extends {
+        } ? undefined extends O ? true : false : false) extends true ? K : never]?: (S[K] extends infer T_1 ? T_1 extends S[K] ? T_1 extends {
+            _zod: {
+                output: infer O_1;
+            };
+        } ? O : never : never : never) | undefined; } extends infer T ? { [K in keyof T]: T[K]; } : never;
+        parse(value: unknown): { [K in keyof S as (S[K] extends {
+            _zod: {
+                output: infer O;
+            };
+        } ? undefined extends O ? true : false : false) extends true ? never : K]: S[K] extends infer T_1 ? T_1 extends S[K] ? T_1 extends {
+            _zod: {
+                output: infer O_1;
+            };
+        } ? O_1 : never : never : never; } & { [K in keyof S as (S[K] extends {
             _zod: {
                 output: infer O;
             };
-        } ? O : never; };
+        } ? undefined extends O ? true : false : false) extends true ? K : never]?: (S[K] extends infer T_1 ? T_1 extends S[K] ? T_1 extends {
+            _zod: {
+                output: infer O_1;
+            };
+        } ? O : never : never : never) | undefined; } extends infer T ? { [K in keyof T]: T[K]; } : never;
         safeParse(value: unknown): {
             success: true;
-            data: { [K in keyof S]: S[K] extends {
+            data: { [K in keyof S as (S[K] extends {
                 _zod: {
                     output: infer O;
                 };
-            } ? O : never; };
+            } ? undefined extends O ? true : false : false) extends true ? never : K]: S[K] extends infer T_1 ? T_1 extends S[K] ? T_1 extends {
+                _zod: {
+                    output: infer O_1;
+                };
+            } ? O_1 : never : never : never; } & { [K in keyof S as (S[K] extends {
+                _zod: {
+                    output: infer O;
+                };
+            } ? undefined extends O ? true : false : false) extends true ? K : never]?: (S[K] extends infer T_1 ? T_1 extends S[K] ? T_1 extends {
+                _zod: {
+                    output: infer O_1;
+                };
+            } ? O : never : never : never) | undefined; } extends infer T ? { [K in keyof T]: T[K]; } : never;
         } | {
             success: false;
             error: unknown;
         };
         check(...checks: import("./zod.js").Check[]): /*elided*/ any;
         register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): /*elided*/ any;
-    }>;
+    }>>;
     /** A fixed-stride element — bound it with `.max(n)` or `.length(n)` before field.array. */
-    array: <E extends z.ZodTypeAny>(element: E) => import("./zod.js").Fluent<{
+    array: <E extends z.ZodTypeAny>(element: E) => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: (E extends {
                 _zod: {
@@ -373,5 +433,5 @@ export declare const reef: {
         };
         check(...checks: import("./zod.js").Check[]): /*elided*/ any;
         register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): /*elided*/ any;
-    }>;
+    }>>;
 };

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

package/dist/contract/types.d.ts

@@ -60,6 +60,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/contract/zod.d.ts

@@ -52,6 +52,10 @@ export interface SchemaDef {
     format?: string;
     shape?: Record<string, ZodLike>;
     element?: ZodLike;
+    /** union members. */
+    options?: readonly ZodLike[];
+    /** literal value. */
+    literal?: unknown;
     cls?: abstract new (...args: any[]) => unknown;
 }
 export declare class SchemaError extends Error {
@@ -143,13 +147,23 @@ declare class ZodUnknown extends ZodType<unknown> {
 declare class ZodInstanceof<T> extends ZodType<T> {
     inner(v: unknown): T;
 }
-type ShapeOutput<S extends Record<string, ZodLike>> = {
-    [K in keyof S]: S[K] extends {
-        _zod: {
-            output: infer O;
-        };
-    } ? O : never;
+/** Members whose output admits `undefined` become optional keys — mirroring
+ *  zod's `z.optional()` object-member semantics (message-domain schemas like
+ *  island prop contracts need this; reef's fixed-width members never produce
+ *  it, so the split preserves their all-required output). */
+type IsOptional<S, K extends keyof S> = S[K] extends {
+    _zod: {
+        output: infer O;
+    };
+} ? undefined extends O ? true : false : false;
+type Flatten<T> = {
+    [K in keyof T]: T[K];
 };
+type ShapeOutput<S extends Record<string, ZodLike>> = Flatten<{
+    [K in keyof S as IsOptional<S, K> extends true ? never : K]: OutputOf<S[K]>;
+} & {
+    [K in keyof S as IsOptional<S, K> extends true ? K : never]?: OutputOf<S[K]>;
+}>;
 /** Strips unknown keys like zod's object parse — output is the shape only. */
 declare class ZodObjectSchema<S extends Record<string, ZodLike>> extends ZodType<ShapeOutput<S>> {
     readonly _zod: {
@@ -179,14 +193,90 @@ type OutputOf<S> = S extends {
         output: infer O;
     };
 } ? O : never;
-declare const number: () => ZodNumber;
-declare const string: () => ZodString;
-declare const boolean_: () => ZodBoolean;
-declare const bigint_: () => ZodBigint;
-declare const unknown_: () => ZodUnknown;
-declare const instanceof_: <T extends abstract new (...args: any[]) => any>(cls: T) => ZodInstanceof<InstanceType<T>>;
-declare const object_: <S extends Record<string, ZodLike>>(shape: S) => ZodObjectSchema<S>;
-declare const array: <E extends ZodLike>(element: E) => ZodArraySchema<E>;
+declare class ZodOptional<E extends ZodLike> extends ZodType<OutputOf<E> | undefined> {
+    readonly _zod: {
+        output: OutputOf<E> | undefined;
+        input: OutputOf<E> | undefined;
+        def: SchemaDef & {
+            type: 'optional';
+            element: E;
+        };
+    };
+    inner(v: unknown): OutputOf<E> | undefined;
+}
+declare class ZodNullable<E extends ZodLike> extends ZodType<OutputOf<E> | null> {
+    readonly _zod: {
+        output: OutputOf<E> | null;
+        input: OutputOf<E> | null;
+        def: SchemaDef & {
+            type: 'nullable';
+            element: E;
+        };
+    };
+    inner(v: unknown): OutputOf<E> | null;
+}
+declare class ZodLiteral<V extends string | number | boolean> extends ZodType<V> {
+    readonly _zod: {
+        output: V;
+        input: V;
+        def: SchemaDef & {
+            type: 'literal';
+        };
+    };
+    inner(v: unknown): V;
+}
+declare class ZodUnion<O extends readonly ZodLike[]> extends ZodType<OutputOf<O[number]>> {
+    readonly _zod: {
+        output: OutputOf<O[number]>;
+        input: OutputOf<O[number]>;
+        def: SchemaDef & {
+            type: 'union';
+            options: O;
+        };
+    };
+    inner(v: unknown): OutputOf<O[number]>;
+}
+declare class ZodRecord<E extends ZodLike> extends ZodType<Record<string, OutputOf<E>>> {
+    readonly _zod: {
+        output: Record<string, OutputOf<E>>;
+        input: Record<string, OutputOf<E>>;
+        def: SchemaDef & {
+            type: 'record';
+            element: E;
+        };
+    };
+    inner(v: unknown): Record<string, OutputOf<E>>;
+}
+/**
+ * Function-typed members — how a props schema declares a `callbackProp`
+ * slot: the wire carries a `{__cb:id}` handle that `unmarshalCallbackProps`
+ * restores to a callable BEFORE contract validation runs, so at parse time
+ * the member is a real function.
+ */
+declare class ZodCallback<F extends (...args: any[]) => any = (...args: unknown[]) => unknown> extends ZodType<F> {
+    readonly _zod: {
+        output: F;
+        input: F;
+        def: SchemaDef & {
+            type: 'function';
+        };
+    };
+    inner(v: unknown): F;
+}
+declare const number: () => Fluent<ZodNumber>;
+declare const string: () => Fluent<ZodString>;
+declare const boolean_: () => Fluent<ZodBoolean>;
+declare const bigint_: () => Fluent<ZodBigint>;
+declare const unknown_: () => Fluent<ZodUnknown>;
+declare const instanceof_: <T extends abstract new (...args: any[]) => any>(cls: T) => Fluent<ZodInstanceof<InstanceType<T>>>;
+declare const object_: <S extends Record<string, ZodLike>>(shape: S) => Fluent<ZodObjectSchema<S>>;
+declare const array: <E extends ZodLike>(element: E) => Fluent<ZodArraySchema<E>>;
+declare const optional: <E extends ZodLike>(element: E) => Fluent<ZodOptional<E>>;
+declare const nullable: <E extends ZodLike>(element: E) => Fluent<ZodNullable<E>>;
+declare const literal: <V extends string | number | boolean>(value: V) => Fluent<ZodLiteral<V>>;
+declare const union: <O extends readonly [ZodLike, ...ZodLike[]]>(options: O) => Fluent<ZodUnion<O>>;
+declare const record: <E extends ZodLike>(element: E) => Fluent<ZodRecord<E>>;
+declare const callback: <F extends (...args: any[]) => any = (...args: unknown[]) => unknown>() => Fluent<ZodCallback<F>>;
 declare const int32: () => ZodNumber;
 declare const uint32: () => ZodNumber;
 declare const float32: () => ZodNumber;
@@ -204,6 +294,10 @@ export type Fluent<S extends ZodLike> = S & {
     max(value: number | bigint): Fluent<S>;
     length(n: number): Fluent<S>;
     int(): Fluent<S>;
+    /** Wraps in an optional member — the `label?: string` spelling. */
+    optional(): Fluent<ZodOptional<S>>;
+    /** Wraps in a nullable member — `T | null`. */
+    nullable(): Fluent<ZodNullable<S>>;
 };
 /** Attaches the `Fluent` methods as non-enumerable own properties. */
 export declare function fluent<S extends ZodType>(schema: S): Fluent<S>;
@@ -216,6 +310,12 @@ export declare const z: {
     array: typeof array;
     instanceof: typeof instanceof_;
     unknown: typeof unknown_;
+    optional: typeof optional;
+    nullable: typeof nullable;
+    literal: typeof literal;
+    union: typeof union;
+    record: typeof record;
+    callback: typeof callback;
     int32: typeof int32;
     uint32: typeof uint32;
     float32: typeof float32;

package/dist/devtools.d.ts

@@ -0,0 +1,223 @@
+/**
+ * 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;
+    concurrency: number;
+    memoryBytes?: number;
+} | {
+    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;
+} | {
+    type: 'task:settle';
+    poolId: string;
+    callId: number;
+    taskId: string;
+    outcome: TaskSettleOutcome;
+    /** dispatch→reply; absent for calls that never ran. */
+    runMs?: number;
+    error?: string;
+} | {
+    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;
+} | {
+    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;
+} | {
+    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;
+} | {
+    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;
+    }[];
+};
+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 event sink (devtools transports hook here); null disables. */
+export declare const setDevtoolsSink: (custom: DevtoolsSink | null) => 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 is installed on this thread. */
+export declare const devtoolsEnabled: () => boolean;
+/**
+ * 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 pools — 'pool-1', 'pool-2', … */
+export declare const nextDevtoolsId: (prefix: string) => string;

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export { bindSharedMemories, defineSharedMemory, field, getDefinedSharedMemoryCount, jsonCodec, registerConnectorFactory } from './contract/sharedMemory.js';
 export { reef } from './contract/reef.js';
+export { z, SchemaError } from './contract/zod.js';
+export type { ZodLike } from './contract/zod.js';
 export type { Codec, Connector, ConnectorContext, ConnectorFactory, FieldDescriptor, FieldGroup, FieldSchema, FixedArrayDescriptor, FixedObjectDescriptor, FlatKey, InferField, PathConnector, SpecPath, SpecSchemas, SharedAccess, SharedMemory, SharedMemoryOptions, SharedSpec, ScalarKind, ListConnector, ListDescriptor, ListFieldSpec, ListFields, ListMember, ListRecord, ListSpec, } from './contract/sharedMemory.js';
 export { msgpackrCodec } from './contract/msgpackrCodec.js';
 export { listSchema } from './contract/listSchema.js';
@@ -27,3 +29,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 { devtoolsEnabled, emitDevtools, installFetchProbe, installMemoryProbe, setDevtoolsSink, } from './devtools.js';
+export type { DevtoolsEvent, DevtoolsSink, DevtoolsThread, EmittedDevtoolsEvent, TaskSettleOutcome, } from './devtools.js';