lopata 0.18.4 → 0.19.0

package/dist/types/api/dispatch.d.ts

@@ -238,10 +238,10 @@ declare const allHandlers: {
         name: string;
         status?: string;
     }): import("./types").WorkflowInstance[];
-    'workflows.getInstance'({ id }: {
+    'workflows.getInstance'({ name, id }: {
         name: string;
         id: string;
-    }): import("./types").WorkflowDetail;
+    }, ctx: HandlerContext): Promise<import("./types").WorkflowDetail>;
     'workflows.terminate'({ name, id }: {
         name: string;
         id: string;

package/dist/types/api/handlers/workflows.d.ts

@@ -5,10 +5,10 @@ export declare const handlers: {
         name: string;
         status?: string;
     }): WorkflowInstance[];
-    'workflows.getInstance'({ id }: {
+    'workflows.getInstance'({ name, id }: {
         name: string;
         id: string;
-    }): WorkflowDetail;
+    }, ctx: HandlerContext): Promise<WorkflowDetail>;
     'workflows.terminate'({ name, id }: {
         name: string;
         id: string;

package/dist/types/bindings/container-cleanup.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Main-side registry of active Docker containers spawned by lopata.
+ *
+ * Containers come from two places: the in-process path (dashboard API
+ * handlers + the legacy/vite-plugin executor in `env.ts`) and the DO worker
+ * threads. DO workers call `register` / `unregister` via postMessage
+ * (`container-registered` / `container-removed` in `do-executor-worker.ts`);
+ * the in-process callers invoke the helpers directly through the
+ * `DockerManager` constructor callbacks.
+ *
+ * Two safety nets:
+ *
+ *   1. An `exit` listener `docker rm -f`s anything still tracked at process
+ *      shutdown. Synchronous (`Bun.spawnSync`) since `exit` doesn't await.
+ *
+ *   2. `reapOrphanContainers()` scans for containers labeled `lopata=1`
+ *      whose `lopata.pid` is no longer alive — cleans up leftovers from
+ *      crashes / SIGKILL where (1) never ran. Invoked once at lopata
+ *      startup from `cli/dev.ts`.
+ */
+/** Marker label on every lopata-managed container. */
+export declare const LOPATA_LABEL_KEY = "lopata";
+export declare const LOPATA_LABEL_VALUE = "1";
+/** Pid sub-label so the reaper can detect orphans of dead processes. */
+export declare const LOPATA_PID_LABEL_KEY = "lopata.pid";
+/** Labels passed to `DockerManager` (constructor) for every `docker run`. */
+export declare function containerLabels(): Record<string, string>;
+export declare function registerContainer(name: string): void;
+export declare function unregisterContainer(name: string): void;
+/** @internal Test hook — current tracked container set. */
+export declare function _activeContainersSnapshot(): string[];
+/**
+ * Reap containers labeled `lopata=1` whose `lopata.pid` is no longer alive.
+ * Returns the number of orphans removed. Silently returns 0 if docker isn't
+ * available so non-container users aren't penalised.
+ */
+export declare function reapOrphanContainers(): Promise<number>;
+/**
+ * @internal Pure-function core of {@link reapOrphanContainers}, exported for
+ * tests. Parses the `docker ps` `{{.Names}}|{{.Label ...}}` table and returns
+ * the container names whose owner pid is unknown, unparseable, or dead.
+ */
+export declare function _selectOrphanNames(listOut: string, alive: (pid: number) => boolean): string[];

package/dist/types/bindings/container-docker.d.ts

@@ -12,8 +12,26 @@ export interface DockerContainerInfo {
     state: string;
     exitCode: number | null;
     ports: Record<string, string>;
+    /** Container labels (e.g. `lopata.pid`) — used to detect a container left by a
+     *  crashed/foreign lopata process before adopting it by name. */
+    labels: Record<string, string>;
+}
+export interface DockerManagerOptions {
+    /** Called after a container is successfully created via `run()`. */
+    onRegister?: (name: string) => void;
+    /** Called after a container is removed via `remove()`. */
+    onRemove?: (name: string) => void;
+    /**
+     * Labels passed to every `docker run` (`--label key=value`).
+     * Cleanup uses these to detect orphans from crashed processes.
+     */
+    labels?: Record<string, string>;
 }
 export declare class DockerManager {
+    private _onRegister?;
+    private _onRemove?;
+    private _labels?;
+    constructor(options?: DockerManagerOptions);
     /**
      * Build an image from a Dockerfile, with lazy mtime-based caching.
      * Skips rebuild if the Dockerfile hasn't changed since last build.
@@ -23,6 +41,12 @@ export declare class DockerManager {
      * Run a container and return its container ID.
      */
     run(options: DockerRunOptions): Promise<string>;
+    /**
+     * Fire the `onRegister` callback for a container we didn't create via
+     * `run()` — e.g. one adopted at startup because it was already running.
+     * Lets cleanup hooks (process-exit handler) track it the same way.
+     */
+    registerExisting(name: string): void;
     /**
      * Stop a running container gracefully.
      */

package/dist/types/bindings/container.d.ts

@@ -86,8 +86,10 @@ export declare class ContainerRuntime {
      */
     cleanup(): Promise<void>;
     /**
-     * Recover host port mappings from docker inspect Ports object.
-     * Format: { "8080/tcp": [{ "HostIp": "...", "HostPort": "49152" }], ... }
+     * Recover host port mappings from the flattened ports map returned by
+     * `DockerManager.inspect()`: { "8080/tcp": "0.0.0.0:32768", ... }.
+     * (inspect() already flattens docker's raw `[{HostIp,HostPort}]` shape, so
+     * the value here is a "host:port" string, not an array.)
      */
     private _recoverPortMappings;
     private _startHealthCheck;

package/dist/types/bindings/do-executor-worker.d.ts

@@ -4,110 +4,75 @@
  * Main thread side: spawns a Worker on first command, maintains a serial
  * command queue, and bridges WebSocket events between main thread and worker.
  */
+import type { WranglerConfig } from '../config';
 import type { DOExecutor, DOExecutorFactory, ExecutorConfig } from './do-executor';
-import type { WsBridgeOutbound } from './do-websocket-bridge';
-/** Commands sent from main thread to worker */
-export type DOCommand = {
-    type: 'fetch';
-    url: string;
-    method: string;
-    headers: [string, string][];
-    body: ArrayBuffer | null;
-} | {
-    type: 'rpc-call';
-    method: string;
-    args: unknown[];
-} | {
-    type: 'rpc-get';
-    prop: string;
-} | {
-    type: 'alarm';
-    retryCount: number;
-} | {
-    type: 'ws-create';
-    wsId: string;
-};
-/** Results returned from worker to main thread */
-export type DOResult = {
-    type: 'fetch';
-    status: number;
-    statusText: string;
-    headers: [string, string][];
-    body: ArrayBuffer | null;
-} | {
-    type: 'rpc-call';
-    value: unknown;
-} | {
-    type: 'rpc-get';
-    value: unknown;
-} | {
-    type: 'alarm';
-} | {
-    type: 'ws-created';
-    wsId: string;
-} | {
-    type: 'error';
-    message: string;
-    stack?: string;
-    name?: string;
-};
-/** Messages from main thread → worker */
-export type DOWorkerMessage = {
-    type: 'command';
-    id: number;
-    command: DOCommand;
-} | {
-    type: 'ws-message';
-    wsId: string;
-    data: string | ArrayBuffer;
-} | {
-    type: 'ws-close';
-    wsId: string;
-    code: number;
-    reason: string;
-    wasClean: boolean;
-} | {
-    type: 'ws-error';
-    wsId: string;
-};
-/** Messages from worker → main thread */
-export type DOMainMessage = {
-    type: 'need-init';
-} | {
-    type: 'ready';
-} | {
-    type: 'result';
-    id: number;
-    result: DOResult;
-} | {
-    type: 'alarm-set';
-    time: number | null;
-} | {
-    type: 'ws-bridge';
-    payload: WsBridgeOutbound;
-};
+export type { DOCommand, DOMainMessage, DoReqStreamAck, DoReqStreamCancel, DoReqStreamChunk, DoReqStreamEnd, DoReqStreamError, DOResult, DoStreamAck, DoStreamCancel, DoStreamChunk, DoStreamEnd, DoStreamError, DOWorkerMessage, } from '../worker-thread/do-protocol';
 export declare class WorkerExecutor implements DOExecutor {
     private _config;
     private _worker;
     private _ready;
     private _readyResolve;
+    private _readyReject;
     private _pending;
     private _nextId;
     private _disposed;
+    /** Swallowed copy of `_priorDisposal`, created lazily on the first command.
+     *  Shared so CONCURRENT first commands all await the prior container's
+     *  teardown — a boolean gate would let the second racer skip straight to
+     *  `docker run` while the old container's `docker rm` is still in flight. */
+    private _priorDisposalGate;
     private _inFlightCount;
+    /** Mirrors of the DO worker's `state` lifecycle, fed by `do-state` signals. */
     private _blocked;
-    private _wsCount;
-    private _bridgedWebSockets;
+    private _aborted;
+    /**
+     * `wsId`s of every open WebSocket this DO's fetch handler returned — both
+     * hibernation (`state.acceptWebSocket`) and plain (`new WebSocketPair`) ones.
+     * Each pins the executor against the idle reaper until it closes. Added when
+     * `executeFetch` registers the bridge socket; removed on the `fetch-ws-close-out`
+     * dispatch (server-side close) and the `_fetchBridge` clientClose envelope
+     * (client disconnect) — both delete from the same set so neither double-counts.
+     */
+    private _openFetchWsIds;
+    /**
+     * Main-side WS bridge for `Response{webSocket}` returned by the DO worker's
+     * fetch handler. The bridge's peer forwards outgoing bytes (Bun.serve → here)
+     * down to the DO worker as `fetch-ws-incoming` / `fetch-ws-close-in`.
+     */
+    private _fetchBridge;
+    /**
+     * Main-side WS bridge for upstream CFWebSockets adopted from env-binding
+     * fetches the DO worker initiated (e.g. `this.env.SVC.fetch('/ws')` returning
+     * a 101). Direction is opposite of `_fetchBridge`: we already hold the real
+     * CFWebSocket from main's `resolveBinding(...).fetch()`, the DO worker side
+     * holds the synthetic user-facing peer.
+     */
+    private _envBindingWsBridge;
+    /** Main-side host of the unified cross-thread RPC channel — env-binding
+     *  call/get/fetch from inside the DO worker (`this.env.SVC.…`), with
+     *  response/request-body streaming. Shared with the user-worker executor;
+     *  channel-specifics injected as hooks. */
+    private _rpcChannel;
+    /** Reconstruction of streamed DO-fetch response bodies (DO worker → main). */
+    private _fetchStreams;
+    /** Outbound request-body pumps for DO-fetch (main → DO worker). A
+     *  `do-req-stream-cancel` from the DO worker (instance code cancelled the
+     *  body) stops the source reader. */
+    private _fetchRequestStreams;
     constructor(config: ExecutorConfig);
     private _ensureWorker;
     private _resolveModulePath;
     private _resolveConfigPath;
     private _resolveDataDir;
     private _sendCommand;
-    private _handleWsBridge;
-    /** Register a real WebSocket for bridging to the worker */
-    _bridgeWebSocket(wsId: string, ws: WebSocket): void;
     executeFetch(request: Request): Promise<Response>;
+    private _pumpFetchRequestBody;
+    /**
+     * Resolve a binding from main's env. Mirrors the user-worker channel:
+     * when `target.instanceId` is set, route through the namespace's `.get()`
+     * so DO-stub redirection works (cross-DO and self-DO access via env-RPC).
+     */
+    private _resolveBinding;
     executeRpc(method: string, args: unknown[]): Promise<unknown>;
     executeRpcGet(prop: string): Promise<unknown>;
     executeAlarm(retryCount: number): Promise<void>;
@@ -115,15 +80,34 @@ export declare class WorkerExecutor implements DOExecutor {
     isBlocked(): boolean;
     activeWebSocketCount(): number;
     isAborted(): boolean;
+    isDisposed(): boolean;
+    /**
+     * Ask the DO worker to tear down its Docker container before we terminate the
+     * thread. terminate() kills the worker's activity/health timers but leaves the
+     * Docker process running — mirrors `InProcessExecutor.dispose()`'s
+     * `containerRuntime.cleanup()`. Bounded so a hung `docker rm` can't block
+     * reload; the thread is terminated right after regardless.
+     */
+    private _cleanupContainer;
     dispose(): Promise<void>;
+    /**
+     * The one teardown sequence — shared by `dispose()` (planned), `onerror`
+     * (worker crashed) and the init-error path, so the three can't drift: mark
+     * disposed, terminate the thread, reject every pending command and the ready
+     * promise with `error`, and dispose every bridge/stream/rpc registry.
+     * Idempotent. Counterpart of `WorkerThreadExecutor._failAll`.
+     */
+    private _teardown;
 }
 export declare class WorkerExecutorFactory implements DOExecutorFactory {
     private _modulePath?;
     private _configPath?;
+    private _wranglerConfig?;
     /**
-     * Set the module and config paths for all executors created by this factory.
-     * Called by the generation manager after loading config.
+     * Set the module + config paths and the parsed env-overridden config for all
+     * executors created by this factory. Called by the generation manager after
+     * loading config.
      */
-    configure(modulePath: string, configPath: string): void;
+    configure(modulePath: string, configPath: string, wranglerConfig?: WranglerConfig): void;
     create(config: ExecutorConfig): DOExecutor;
 }

package/dist/types/bindings/do-executor.d.ts

@@ -1,4 +1,5 @@
 import type { Database } from 'bun:sqlite';
+import type { WranglerConfig } from '../config';
 import type { ContainerConfig } from './container';
 import type { DurableObjectBase, DurableObjectIdImpl, DurableObjectLimits } from './durable-object';
 export interface ExecutorConfig {
@@ -6,11 +7,24 @@ export interface ExecutorConfig {
     db: Database;
     namespaceName: string;
     cls: new (ctx: any, env: unknown) => DurableObjectBase;
-    env: unknown;
+    env: Record<string, unknown>;
     dataDir?: string;
     limits?: DurableObjectLimits;
     containerConfig?: ContainerConfig;
     onAlarmSet?: (time: number | null) => void;
+    /** @internal Worker-thread DO executors re-import the user module + config
+     *  inside their Bun Worker; the factory injects these paths. */
+    _modulePath?: string;
+    _configPath?: string;
+    /** @internal Main's already-parsed, env-overridden wrangler config. Passed to
+     *  the DO worker so it doesn't re-load from `_configPath` WITHOUT the `--env`
+     *  overrides (which the re-parse silently dropped). */
+    _wranglerConfig?: WranglerConfig;
+    /** @internal Disposal of the PRIOR executor for this same id, still in flight
+     *  (its Docker container is being `docker rm`'d). A container DO awaits this
+     *  before its first command so a fresh `docker run` for the same name doesn't
+     *  race the teardown — which could `docker rm -f` the replacement. */
+    _priorDisposal?: Promise<void>;
 }
 export interface DOExecutor {
     /** Execute a fetch call on the DO instance */
@@ -29,6 +43,10 @@ export interface DOExecutor {
     activeWebSocketCount(): number;
     /** Whether the instance has been aborted */
     isAborted(): boolean;
+    /** Whether the underlying executor is dead (e.g. its Worker crashed). A
+     *  disposed executor is unusable — the namespace drops it and recreates a
+     *  fresh one on next access. Optional: executors that can't die report `false`. */
+    isDisposed?(): boolean;
     /** Hot-swap the DO class and env without disposing (preserves WebSocket connections) */
     reloadClass?(cls: new (ctx: any, env: unknown) => DurableObjectBase, env: unknown): void;
     /** Kill the instance */
@@ -36,4 +54,7 @@ export interface DOExecutor {
 }
 export interface DOExecutorFactory {
     create(config: ExecutorConfig): DOExecutor;
+    /** Tell the factory where user code lives + the already-parsed env-overridden
+     *  config (only used by worker-thread DO executors). */
+    configure?(modulePath: string, configPath: string, wranglerConfig?: WranglerConfig): void;
 }

package/dist/types/bindings/do-worker-env.d.ts

@@ -8,16 +8,25 @@
  */
 import { Database } from 'bun:sqlite';
 import type { WranglerConfig } from '../config';
-import { DurableObjectNamespaceImpl } from './durable-object';
+import { RpcClient } from '../worker-thread/rpc-shared';
+import type { WsGuestBridge } from '../worker-thread/ws-bridge-shared';
+import type { DOMainMessage } from './do-executor-worker';
+/** Build an RpcClient that bridges DO-worker → main over the DO executor channel. */
+export declare function createDoEnvRpc(post: (msg: DOMainMessage) => void): RpcClient;
 /**
  * Build a minimal env for use inside a DO worker thread.
- * DOs created here use InProcessExecutor (nested DOs run in the worker thread).
+ *
+ * Stateless bindings (KV/R2/D1/queue producer/nested DO) are instantiated
+ * locally against the shared SQLite/filesystem. Stateful ones (service
+ * bindings, email, workflow, …) become RPC proxies that route through main
+ * via the DO-executor message channel.
+ *
+ * `envWsBridge` is shared with `do-worker-entry.ts`'s message router: when an
+ * env-binding fetch returns a 101 response with a `webSocketId`, the proxy
+ * here calls `envWsBridge.createBridgedSocket(id)` to reconstruct a
+ * user-facing CFWebSocket whose events flow over the bridge to main.
  */
-export declare function buildWorkerEnv(config: WranglerConfig, dataDir: string): {
+export declare function buildWorkerEnv(config: WranglerConfig, dataDir: string, baseDir: string, rpc: RpcClient, _hostNamespaceName: string, envWsBridge: WsGuestBridge<DOMainMessage>): {
     db: Database;
     env: Record<string, unknown>;
-    doNamespaces: {
-        className: string;
-        namespace: DurableObjectNamespaceImpl;
-    }[];
 };

package/dist/types/bindings/durable-object.d.ts

@@ -113,6 +113,10 @@ export declare class DurableObjectIdImpl {
     toString(): string;
     equals(other: DurableObjectIdImpl): boolean;
 }
+/** Deterministic id from name. Shared by the in-process namespace and the thread-mode proxy. */
+export declare function hashIdFromName(name: string): string;
+/** Random 128-bit id matching CF's `newUniqueId` hex shape. */
+export declare function randomUniqueIdHex(): string;
 export declare class DurableObjectStateImpl {
     readonly id: DurableObjectIdImpl;
     readonly storage: SqliteDurableObjectStorage;
@@ -166,9 +170,21 @@ export declare class DurableObjectBase {
 }
 export declare class DurableObjectNamespaceImpl {
     private _executors;
+    /** In-flight disposals per id (container DOs only). A respawn for the same id
+     *  chains its first command on this so a fresh `docker run` doesn't race the
+     *  old container's teardown. */
+    private _disposing;
     private _stubs;
     private _knownIds;
     private _class?;
+    private _externalClassName?;
+    /**
+     * In thread mode the real DO class isn't available on main. The user-worker
+     * introspects its prototype and reports `alarm()` presence back through the
+     * `'ready'` message; `GenerationManager` forwards it via `_setAlarmHandlerHint`.
+     * Read by `hasAlarmHandler()` when `_externalClassName` is set.
+     */
+    private _externalAlarmHandler?;
     private _env?;
     private db;
     private namespaceName;
@@ -186,9 +202,22 @@ export declare class DurableObjectNamespaceImpl {
     constructor(db: Database, namespaceName: string, dataDir?: string, limits?: DurableObjectLimits, factory?: DOExecutorFactory, clock?: Clock);
     private _getFactory;
     /** Called after worker module is loaded to wire the actual class */
-    _setClass(cls: new (ctx: DurableObjectStateImpl, env: unknown) => DurableObjectBase, env: unknown, generationId?: number): void;
+    _setClass(cls: new (ctx: DurableObjectStateImpl, env: unknown) => DurableObjectBase, env: Record<string, unknown>, generationId?: number): void;
+    /**
+     * Thread-mode counterpart of `_setClass`: the real DO class lives in a worker
+     * thread, so main only stores the className for diagnostics and treats the
+     * namespace as wired. Must be used with an executor factory that does not
+     * need the JS class on main (e.g. `WorkerExecutorFactory`).
+     */
+    _setExternalClass(className: string, env: Record<string, unknown>, generationId?: number): void;
     /** Set container config for this namespace (makes it a container namespace) */
     _setContainerConfig(config: ContainerConfig): void;
+    /**
+     * Hint for thread-mode namespaces: whether the (worker-side) DO class defines
+     * an `alarm()` handler. Called by `GenerationManager` after the worker's
+     * `'ready'` message lands. Idempotent — overwrites on each reload.
+     */
+    _setAlarmHandlerHint(value: boolean): void;
     /** @internal Restore all persisted alarms for this namespace */
     private _restoreAlarms;
     /** @internal Schedule a timer for an alarm */
@@ -197,12 +226,36 @@ export declare class DurableObjectNamespaceImpl {
     private _fireAlarm;
     /** @internal Get or create a DO executor by id string */
     private _getOrCreateExecutor;
+    /**
+     * @internal Dispose an executor and, for container DOs, record the disposal so a
+     * respawn for the same id can wait for the old container's teardown (`docker rm`)
+     * to finish before its own `docker run` — otherwise the teardown can race and
+     * `docker rm -f` the freshly started replacement. Non-container DOs skip the
+     * tracking (dispose is fast and there's no shared Docker name to collide on).
+     */
+    private _disposeExecutor;
+    /**
+     * @internal Dispose an executor detached from the namespace (during reload swap)
+     * once its in-flight command settles, so an old-generation request mid-DO-call
+     * isn't rejected with "Worker terminated". Polls `isActive()`; bounded (≈10s) so
+     * a hung command can't keep the old worker thread alive indefinitely.
+     */
+    private _disposeExecutorWhenIdle;
+    private _pollThenDispose;
     /** @internal Evict idle executors */
     private _evictIdle;
     /** @internal Clear all in-memory alarm timers (alarms persist in DB for new generation to restore) */
     clearAlarmTimers(): void;
-    /** @internal Destroy this namespace: clear timers, evict executors without active WebSockets */
-    destroy(): void;
+    /**
+     * @internal Destroy this namespace: clear timers, evict executors without
+     * active WebSockets. Pass `{ force: true }` for final teardown (test dispose /
+     * shutdown) to dispose EVERY executor and never restart the eviction timer —
+     * there's no next generation to reap survivors, and a restarted 30s interval
+     * would outlive teardown (and the DB close that follows).
+     */
+    destroy(options?: {
+        force?: boolean;
+    }): void;
     /** @internal Get a raw instance for testing (no proxy) */
     _getInstance(idStr: string): DurableObjectBase | null;
     /** @internal Get the executor for a given id */
@@ -212,10 +265,19 @@ export declare class DurableObjectNamespaceImpl {
         id: string;
         wsCount: number;
     }>;
+    /** @internal Whether any executor in this namespace currently holds at least one accepted WebSocket. */
+    hasActiveWebSockets(): boolean;
     /** @internal List all instance IDs in this namespace (from DB). */
     _listInstanceIds(): string[];
-    /** Whether the DO class defines an alarm() handler */
+    /**
+     * Whether the DO class defines an alarm() handler. In thread mode the class
+     * lives on the worker, so main relies on the hint shipped through the
+     * worker's `'ready'` message (see `_setAlarmHandlerHint`). Returns `false`
+     * during the brief window between `_setExternalClass` and the hint arriving.
+     */
     hasAlarmHandler(): boolean;
+    /** @internal Whether the namespace is wired (class set, in-process or external). */
+    private _isWired;
     /** @internal Trigger the alarm handler immediately (used by dashboard) */
     triggerAlarm(idStr: string): Promise<void>;
     /** @internal Fire all alarms whose scheduled time is <= clock.now(). Returns an array of promises. */

package/dist/types/bindings/queue.d.ts

@@ -66,8 +66,11 @@ export declare class QueueConsumer {
     private batchTimer;
     private polling;
     private _activeDeliveries;
+    /** Optional hook to register an in-flight batch with reload-drain accounting,
+     *  so a generation isn't terminated mid-batch (thread mode). */
+    private _trackBatch?;
     private clock;
-    constructor(db: Database, config: ConsumerConfig, handler: QueueHandler, env: Record<string, unknown>, workerName?: string, clock?: Clock);
+    constructor(db: Database, config: ConsumerConfig, handler: QueueHandler, env: Record<string, unknown>, workerName?: string, clock?: Clock, trackBatch?: (p: Promise<unknown>) => void);
     start(intervalMs?: number): void;
     stop(): void;
     poll(): Promise<void>;

package/dist/types/bindings/rpc-stub.d.ts

@@ -9,12 +9,34 @@
 export declare const RPC_TARGET_BRAND: unique symbol;
 export declare function isRpcTarget(value: unknown): boolean;
 export declare const NON_RPC_PROPS: Set<string | symbol>;
+/** No-op disposer shared by every proxy that needs to satisfy `using` declarations. */
+export declare const noopDispose: () => void;
+/**
+ * Build a Proxy that exposes `.fetch` (HTTP round-trip) and turns any other
+ * property access into a method call. Used to construct cross-thread binding
+ * proxies — main-worker service bindings, DO stubs, and DO-worker env-binding
+ * proxies all share this shape.
+ *
+ * `callbacks.call` is invoked for any prop that isn't `'fetch'` or in
+ * `NON_RPC_PROPS`. `extras` overrides specific props (DO stubs use it to
+ * surface `id`/`name`, service bindings to surface `connect`). Per-prop
+ * methods are cached so hot callers don't allocate a fresh closure per
+ * access.
+ */
+export declare function makeBindingProxy(callbacks: {
+    fetch: (input: Request | string | URL, init?: RequestInit) => Promise<Response>;
+    call: (prop: string, args: unknown[]) => unknown;
+    /** Optional property read (`await binding.prop`). When supplied, the
+     *  per-prop callable is also thenable, issuing a property-get instead of
+     *  resolving to the function itself. */
+    getProperty?: (prop: string) => Promise<unknown>;
+}, extras?: Record<string | symbol, unknown>): Record<string, unknown>;
 /**
  * Wrap an RpcTarget instance in a Proxy that mimics CF stub behavior:
  * - Method calls: validate args → call → wrap return value
  * - Property access: thenable pattern, wraps returned RpcTarget/function values
  * - Filters `_`-prefixed properties (returns undefined)
- * - Symbol.dispose → no-op
+ * - Symbol.dispose / Symbol.asyncDispose → undefined (spec-defined no-op for `using`)
  * - dup() → new stub wrapping same target
  */
 export declare function createRpcStub(target: object): object;

package/dist/types/bindings/scheduled.d.ts

@@ -1,4 +1,3 @@
-import { ExecutionContext } from '../execution-context';
 export interface ScheduledController {
     readonly scheduledTime: number;
     readonly cron: string;
@@ -20,6 +19,17 @@ interface ParsedCron {
 export declare function parseCron(expression: string): ParsedCron;
 export declare function cronMatchesDate(cron: ParsedCron, date: Date): boolean;
 export declare function createScheduledController(cron: string, scheduledTime: number): ScheduledController;
-type ScheduledHandler = (controller: ScheduledController, env: Record<string, unknown>, ctx: ExecutionContext) => Promise<void>;
-export declare function startCronScheduler(crons: string[], handler: ScheduledHandler, env: Record<string, unknown>, workerName?: string): NodeJS.Timer;
+/**
+ * Generic cron timer. `invoke` is called with the matched expression and the
+ * tick time; the caller decides how to dispatch (in-process handler vs RPC).
+ */
+export declare function startCronTimer(crons: string[], invoke: (cronExpr: string, now: Date) => Promise<unknown>, workerName?: string, 
+/**
+ * Per-cron last-fired-minute dedup state, keyed by cron expression. Pass a map
+ * OWNED BY THE GENERATION MANAGER (not per-generation) so it survives reloads:
+ * a fresh per-generation map would start empty and re-fire a cron for a minute
+ * the previous generation already handled — for `* * * * *` that's nearly every
+ * save. Defaults to a local map for standalone callers/tests.
+ */
+lastFiredMinute?: Map<string, number>): NodeJS.Timer;
 export {};

package/dist/types/bindings/service-binding.d.ts

@@ -7,12 +7,24 @@
  * - `.myProperty` — RPC property access (returns thenable/Promise)
  * - `.connect()` — stub for TCP socket (throws — not supported in dev)
  */
+import type { ResolvedTarget } from '../worker-registry';
 export interface ServiceBindingLimits {
     /** Max subrequests per top-level request (CF default: 1000 for workers, 32 for service bindings) */
     maxSubrequests?: number;
     /** Max payload size in bytes for RPC arguments (CF default: 32 MiB) */
     maxRpcPayloadSize?: number;
 }
+/** Error thrown by `connect()` (both in-process and worker-thread paths). */
+export declare function serviceBindingConnectError(name: string): Error;
+/**
+ * Resolve the call target for a service binding RPC (`fetch` or method):
+ * a named entrypoint class, an unnamed default class, or the default object.
+ *
+ * Used by `ServiceBinding._getTarget` (in-process) and the worker-thread's
+ * `invokeEntrypointRpc`. Single source of truth so the in-process and
+ * thread-mode paths can't drift.
+ */
+export declare function resolveEntrypointTarget(workerModule: Record<string, unknown>, entrypoint: string | undefined, ctx: unknown, env: unknown): Record<string, unknown>;
 export declare class ServiceBinding {
     private _resolver;
     private _entrypoint;
@@ -21,10 +33,7 @@ export declare class ServiceBinding {
     _subrequestCount: number;
     private _props;
     constructor(serviceName: string, entrypoint?: string, limits?: ServiceBindingLimits, props?: Record<string, unknown>);
-    _wire(resolverOrModule: (() => {
-        workerModule: Record<string, unknown>;
-        env: Record<string, unknown>;
-    }) | Record<string, unknown>, env?: Record<string, unknown>): void;
+    _wire(resolverOrModule: (() => ResolvedTarget) | Record<string, unknown>, env?: Record<string, unknown>): void;
     get isWired(): boolean;
     private _resolve;
     private _checkSubrequestLimit;

package/dist/types/bindings/static-assets.d.ts

@@ -30,7 +30,7 @@ export declare class StaticAssets {
     private headerRules;
     private redirectRules;
     constructor(directory: string, htmlHandling?: string, notFoundHandling?: string, limits?: StaticAssetsLimits);
-    fetch(request: Request): Promise<Response>;
+    fetch(input: Request | string | URL): Promise<Response>;
     private getRedirectRules;
     /**
      * Returns Response for 3xx redirects, string for 200 rewrites, or null for no match.