@abot-ai/runtime 1.2.0 → 1.3.0

package/dist/src/runtime/request/session-admission.js

@@ -0,0 +1,88 @@
+/** Coordinates background admission with requests from every environment caller. */
+export class SessionRequestAdmission {
+    isDeleted;
+    active = new Map();
+    reserved = new Set();
+    waiters = new Map();
+    idleWaiters = new Set();
+    closed = false;
+    constructor(isDeleted) {
+        this.isDeleted = isDeleted;
+    }
+    tryReserve(sessionId) {
+        if (this.closed)
+            return null;
+        if (this.isDeleted(sessionId))
+            return null;
+        if (this.reserved.has(sessionId))
+            return null;
+        if ((this.active.get(sessionId) ?? 0) > 0)
+            return null;
+        this.reserved.add(sessionId);
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.reserved.delete(sessionId);
+            for (const notify of this.waiters.get(sessionId) ?? [])
+                notify();
+            this.waiters.delete(sessionId);
+            this.notifyIdle();
+        };
+    }
+    async run(sessionId, execute) {
+        this.requireOpenAdmission();
+        while (this.reserved.has(sessionId)) {
+            await new Promise((resolve) => {
+                const waiting = this.waiters.get(sessionId) ?? new Set();
+                waiting.add(resolve);
+                this.waiters.set(sessionId, waiting);
+            });
+            this.requireOpenAdmission();
+        }
+        if (this.isDeleted(sessionId))
+            throw new Error("session_deleted");
+        this.active.set(sessionId, (this.active.get(sessionId) ?? 0) + 1);
+        try {
+            return await execute();
+        }
+        finally {
+            const remaining = (this.active.get(sessionId) ?? 1) - 1;
+            if (remaining > 0)
+                this.active.set(sessionId, remaining);
+            else
+                this.active.delete(sessionId);
+            this.notifyIdle();
+        }
+    }
+    close() {
+        this.closed = true;
+        for (const waiting of this.waiters.values()) {
+            for (const notify of waiting)
+                notify();
+        }
+        this.waiters.clear();
+    }
+    whenIdle() {
+        if (this.isIdle())
+            return Promise.resolve();
+        return new Promise((resolve) => this.idleWaiters.add(resolve));
+    }
+    requireOpenAdmission() {
+        if (this.closed)
+            throw new Error("runtime_request_admission_closed");
+    }
+    isIdle() {
+        if (this.active.size > 0)
+            return false;
+        return this.reserved.size === 0;
+    }
+    notifyIdle() {
+        if (!this.isIdle())
+            return;
+        for (const notify of this.idleWaiters)
+            notify();
+        this.idleWaiters.clear();
+    }
+}

package/dist/src/runtime/request/supervisor-root-execution-diagnostics.d.ts

@@ -1,6 +1,6 @@
 import type { RoleCallFrame, RoleCallLedgerHead, RoleChildReturnContext } from "../orchestration/role-calls/index.js";
 import type { RuntimeDelegateRoleId } from "../orchestration/roles.js";
-export type SupervisorRootFailureStage = "project_activation" | "project_worker_catalog" | "decide" | "publish_title" | "publish_acknowledgement" | "apply_root_transition" | "invoke_child" | "project_resume" | "bind_observation" | "project_observation" | "compose_response" | "seal_response" | "commit_response";
+export type SupervisorRootFailureStage = "project_activation" | "project_worker_catalog" | "decide" | "recall_memory" | "publish_title" | "publish_acknowledgement" | "apply_root_transition" | "invoke_child" | "project_resume" | "bind_observation" | "project_observation" | "compose_response" | "seal_response" | "commit_response";
 export type SupervisorRootDiagnosticContext = Readonly<{
     requestId: string;
     allowedRoleIds: readonly RuntimeDelegateRoleId[];

package/dist/src/runtime/request/supervisor-root-execution.js

@@ -11,18 +11,26 @@ export const SUPERVISOR_ROOT_CONTRACT = Object.freeze({
     async decide(request, options) {
         return runSupervisorDecision(request, {
             call: options.call,
+            memoryRecallCount: options.head.state.memoryRecalls.length,
             toolResults: options.toolResults,
             includeAcknowledgement: options.includeAcknowledgement,
             includeTitle: options.includeTitle,
             allowedRoleIds: options.allowedRoleIds,
             availableWorkerCapabilityCatalog: options.availableWorkerCapabilityCatalog,
+            ...(options.memoryRecallMessage
+                ? { memoryRecallMessage: options.memoryRecallMessage }
+                : {}),
             ...(options.resume ? { resume: options.resume } : {}),
         });
     },
     async authorResponse(request, options) {
         return runSupervisorAuthoredResponse(request, {
+            responseRecommendation: options.responseRecommendation,
             call: options.call,
             toolResults: options.toolResults,
+            ...(options.memoryRecallMessage
+                ? { memoryRecallMessage: options.memoryRecallMessage }
+                : {}),
             steeringSnapshot: projectRequestSteeringSnapshot(request.requestSteering, options.steeringVersion),
             ...(options.resume ? { resume: options.resume } : {}),
         });

package/dist/src/runtime/runtime-environment.d.ts

@@ -0,0 +1,31 @@
+import { SessionRequestAdmission } from "./request/session-admission.js";
+import type { EventSinkFactory, RuntimeConfig } from "./ports.js";
+import type { RuntimeApplicationOverrides, RuntimeEnvironmentServices } from "./composition.js";
+export declare function createRuntimeEnvironment(config: RuntimeConfig, overrides?: RuntimeApplicationOverrides): {
+    services: Readonly<{
+        config: RuntimeConfig;
+        sessions: import("./ports.js").SessionStore;
+        attachments: import("./index.js").RuntimeAttachmentStore;
+        tools: import("./ports.js").ToolRegistry;
+        models: import("./ports.js").ModelGatewayClient;
+        events: EventSinkFactory;
+        sessionMemoryCompactor: import("./context/session-memory/contracts.js").SessionMemoryCompactor;
+        longTermMemory: import("./index.js").LongTermMemoryService;
+        scheduler?: import("./index.js").SchedulerService;
+        startScheduler?: () => Promise<void>;
+        stopScheduler?: () => Promise<void>;
+        requestAdmission?: SessionRequestAdmission;
+    }>;
+    requests: Readonly<{
+        steer?: (requestId: string, input: Readonly<{
+            steerId: string;
+            text: string;
+        }>) => Promise<import("./request/request-steering.js").RequestSteeringAppendResult>;
+        handle: (ws: import("ws").default, message: import("./request/contracts.js").RunRequestMessage, options?: import("./composition.js").RuntimeRequestOptions) => Promise<void>;
+    }>;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    subscribeScheduledEvents: (listener: (event: import("./adapters/scheduled-request-outcome.js").ScheduledRequestEvent) => void) => () => void;
+};
+export declare function recomposeRuntimeEnvironment(config: RuntimeConfig, bound: RuntimeEnvironmentServices | undefined, resolved: RuntimeApplicationOverrides): RuntimeEnvironmentServices;
+export declare function rebindRuntimeEnvironmentEvents(bound: RuntimeEnvironmentServices, events: EventSinkFactory): RuntimeEnvironmentServices | undefined;

package/dist/src/runtime/runtime-environment.js

@@ -0,0 +1,102 @@
+import { createDefaultAttachmentStore, createDefaultEventSinkFactory, createDefaultModelGatewayClient, createDefaultLongTermMemoryService, createDefaultSessionStore, createDefaultToolRegistry, } from "./default-environment-adapters.js";
+import { createBoundRuntimeRequestHandler } from "./request/bound-runtime-handler.js";
+import { createModelSessionMemoryCompactor } from "./context/session-memory/index.js";
+import { createSessionLifecycleStore } from "./session/session-lifecycle-store.js";
+import { bindManagedSessionAttachmentDeletion, deleteSessionAttachmentsIfSupported, } from "./session/session-attachment-deletion.js";
+import { SessionRequestAdmission } from "./request/session-admission.js";
+import { createRuntimeScheduler } from "./adapters/scheduler-runtime.js";
+// Composition metadata, never request state. A rebound graph retains caller
+// supplied adapters while replacing closures that belong to its old scheduler.
+const environmentCompositions = new WeakMap();
+export function createRuntimeEnvironment(config, overrides = {}) {
+    const backingSessions = overrides.sessions ?? createDefaultSessionStore(config);
+    const attachments = overrides.attachments ?? createDefaultAttachmentStore(config);
+    const sessionLifecycle = createSessionLifecycleStore(backingSessions, (result) => deleteSessionAttachmentsIfSupported(attachments, result.sessionId));
+    bindManagedSessionAttachmentDeletion(sessionLifecycle.store, attachments);
+    const admission = new SessionRequestAdmission(sessionLifecycle.isDeleted);
+    const scheduling = createRuntimeScheduler({
+        config,
+        sessions: sessionLifecycle.store,
+        admission,
+        isDeleted: sessionLifecycle.isDeleted,
+        handle: (ws, message, options) => rawRequests.handle(ws, message, options),
+        requestOptions: overrides.scheduledRequestOptions,
+    });
+    sessionLifecycle.onDeleted(async (sessionId) => {
+        await scheduling.ensureStarted();
+        await scheduling.scheduler.deleteSession(sessionId);
+    });
+    const tools = overrides.tools ??
+        createDefaultToolRegistry(config, {
+            service: scheduling.scheduler,
+            ready: scheduling.ensureStarted,
+        });
+    const models = overrides.models ?? createDefaultModelGatewayClient(config);
+    const services = Object.freeze({
+        config,
+        sessions: sessionLifecycle.store,
+        attachments,
+        tools,
+        models,
+        events: overrides.events ?? createDefaultEventSinkFactory(config),
+        sessionMemoryCompactor: overrides.sessionMemoryCompactor ?? createModelSessionMemoryCompactor(),
+        longTermMemory: overrides.longTermMemory ??
+            createDefaultLongTermMemoryService(config, models),
+        scheduler: scheduling.scheduler,
+        startScheduler: scheduling.start,
+        stopScheduler: scheduling.stop,
+        requestAdmission: admission,
+    });
+    // The scheduler has already atomically reserved admission before this handler.
+    let rawRequests = createBoundRuntimeRequestHandler({
+        ...services,
+        requestAdmission: undefined,
+    });
+    const requests = createBoundRuntimeRequestHandler(services);
+    environmentCompositions.set(services, {
+        overrides: { ...overrides, sessions: backingSessions },
+        bindScheduledEvents(events) {
+            // Each invocation captures one immutable handler. An event-only host
+            // override affects future runs without mutating a delegating factory.
+            rawRequests = createBoundRuntimeRequestHandler({
+                ...services,
+                events,
+                requestAdmission: undefined,
+            });
+        },
+    });
+    return {
+        services,
+        requests,
+        start: scheduling.start,
+        stop: scheduling.stop,
+        subscribeScheduledEvents: scheduling.subscribe,
+    };
+}
+export function recomposeRuntimeEnvironment(config, bound, resolved) {
+    const previous = bound
+        ? environmentCompositions.get(bound)?.overrides
+        : undefined;
+    const replacesComposedToolRegistry = previous !== undefined && resolved.tools === bound?.tools;
+    const tools = replacesComposedToolRegistry ? previous.tools : resolved.tools;
+    const sessions = resolved.sessions === bound?.sessions
+        ? (previous?.sessions ?? resolved.sessions)
+        : resolved.sessions;
+    return createRuntimeEnvironment(config, {
+        ...resolved,
+        sessions,
+        tools,
+        scheduledRequestOptions: previous?.scheduledRequestOptions,
+    }).services;
+}
+export function rebindRuntimeEnvironmentEvents(bound, events) {
+    const composition = environmentCompositions.get(bound);
+    if (!composition)
+        return events === bound.events ? bound : undefined;
+    composition.bindScheduledEvents(events);
+    if (events === bound.events)
+        return bound;
+    const services = Object.freeze({ ...bound, events });
+    environmentCompositions.set(services, composition);
+    return services;
+}

package/dist/src/runtime/runtime-host-environment.d.ts

@@ -0,0 +1,8 @@
+import type { RuntimeConfig, RuntimeHostStartOptions } from "./ports.js";
+import type { RuntimeEnvironmentServices } from "./composition.js";
+import type { DefaultRuntimeHostBindings } from "./runtime-host.js";
+export declare function resolveRuntimeHostEnvironmentServices(params: Readonly<{
+    config?: RuntimeConfig;
+    defaults: DefaultRuntimeHostBindings;
+    options: RuntimeHostStartOptions;
+}>): RuntimeEnvironmentServices | undefined;

package/dist/src/runtime/runtime-host-environment.js

@@ -0,0 +1,57 @@
+import { createDefaultAttachmentStore, createDefaultEventSinkFactory, createDefaultLongTermMemoryService, createDefaultModelGatewayClient, createDefaultSessionStore, } from "./default-environment-adapters.js";
+import { createModelSessionMemoryCompactor } from "./context/session-memory/index.js";
+import { rebindRuntimeEnvironmentEvents, recomposeRuntimeEnvironment, } from "./runtime-environment.js";
+export function resolveRuntimeHostEnvironmentServices(params) {
+    const bound = params.defaults.services;
+    const runtimeConfig = params.options.runtimeConfig ?? bound?.config ?? params.config;
+    if (!runtimeConfig) {
+        return undefined;
+    }
+    const mayReuseBound = bound?.config === runtimeConfig;
+    const mayUseLegacyDefaults = !bound && params.config === runtimeConfig;
+    const sessions = params.options.sessionStore ??
+        (mayReuseBound ? bound.sessions : undefined) ??
+        (mayUseLegacyDefaults ? params.defaults.sessionStore : undefined) ??
+        createDefaultSessionStore(runtimeConfig);
+    const attachments = params.options.attachmentStore ??
+        (mayReuseBound ? bound.attachments : undefined) ??
+        (mayUseLegacyDefaults ? params.defaults.attachmentStore : undefined) ??
+        createDefaultAttachmentStore(runtimeConfig);
+    const tools = params.options.toolRegistry ??
+        (mayReuseBound ? bound.tools : undefined) ??
+        (mayUseLegacyDefaults ? params.defaults.toolRegistry : undefined);
+    const models = params.options.modelGatewayClient ??
+        (mayReuseBound ? bound.models : undefined) ??
+        (mayUseLegacyDefaults ? params.defaults.modelGatewayClient : undefined) ??
+        createDefaultModelGatewayClient(runtimeConfig);
+    const events = params.options.eventSinkFactory ??
+        (mayReuseBound ? bound.events : undefined) ??
+        (mayUseLegacyDefaults ? params.defaults.eventSinkFactory : undefined) ??
+        createDefaultEventSinkFactory(runtimeConfig);
+    const sessionMemoryCompactor = bound?.sessionMemoryCompactor ?? createModelSessionMemoryCompactor();
+    const mayReuseBoundLongTermMemory = mayReuseBound && models === bound?.models;
+    const longTermMemory = params.options.longTermMemoryService ??
+        (mayReuseBoundLongTermMemory ? bound?.longTermMemory : undefined) ??
+        createDefaultLongTermMemoryService(runtimeConfig, models);
+    const reusesBoundExecutionServices = mayReuseBound &&
+        sessions === bound.sessions &&
+        attachments === bound.attachments &&
+        tools === bound.tools &&
+        models === bound.models &&
+        sessionMemoryCompactor === bound.sessionMemoryCompactor &&
+        longTermMemory === bound.longTermMemory;
+    const rebound = reusesBoundExecutionServices
+        ? rebindRuntimeEnvironmentEvents(bound, events)
+        : undefined;
+    if (rebound)
+        return rebound;
+    return recomposeRuntimeEnvironment(runtimeConfig, bound, {
+        sessions,
+        attachments,
+        tools,
+        models,
+        events,
+        sessionMemoryCompactor,
+        longTermMemory,
+    });
+}

package/dist/src/runtime/runtime-host-lifecycle.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeEnvironmentServices, RuntimeRequestHandler } from "./composition.js";
+import type { RuntimeHostHandle } from "./ports.js";
+/** Keep legacy synchronous start while exposing and enforcing async readiness. */
+export declare function startRuntimeHostLifecycle(services: RuntimeEnvironmentServices | undefined, requests: RuntimeRequestHandler | undefined, connect: (requests: RuntimeRequestHandler | undefined) => RuntimeHostHandle): RuntimeHostHandle;

package/dist/src/runtime/runtime-host-lifecycle.js

@@ -0,0 +1,64 @@
+import { acquireHostScheduler } from "./runtime-host-scheduler-ownership.js";
+/** Keep legacy synchronous start while exposing and enforcing async readiness. */
+export function startRuntimeHostLifecycle(services, requests, connect) {
+    let transport;
+    let stopping;
+    let stopped = false;
+    const scheduler = acquireHostScheduler(services);
+    const ready = scheduler.ready.then(() => {
+        if (stopped)
+            throw new Error("runtime_host_stopped");
+    });
+    function stop() {
+        if (stopping)
+            return stopping;
+        stopped = true;
+        const shutdowns = [transport?.stop, scheduler.release];
+        stopping = Promise.all(shutdowns.map(async (shutdown) => shutdown?.())).then(() => undefined);
+        return stopping;
+    }
+    function assertHostRunning() {
+        if (stopped)
+            throw new Error("runtime_host_stopped");
+    }
+    const steer = requests?.steer?.bind(requests);
+    const readyRequests = requests
+        ? Object.freeze({
+            ...requests,
+            ...(steer
+                ? {
+                    async steer(...args) {
+                        await ready;
+                        assertHostRunning();
+                        return steer(...args);
+                    },
+                }
+                : {}),
+            async handle(...args) {
+                await ready;
+                assertHostRunning();
+                return requests.handle(...args);
+            },
+        })
+        : undefined;
+    // Hosts that use the historical { stop } handle still get automatic startup
+    // and cleanup. Reading ready is optional and surfaces the original failure.
+    void ready.catch(async (error) => {
+        await stop().catch((cleanupError) => {
+            console.error("Runtime host cleanup failed:", cleanupError);
+        });
+        if (error instanceof Error && error.message === "runtime_host_stopped")
+            return;
+        console.error("Runtime host startup failed:", error);
+    });
+    try {
+        transport = connect(readyRequests);
+    }
+    catch (error) {
+        void stop().catch((cleanupError) => {
+            console.error("Runtime host cleanup failed:", cleanupError);
+        });
+        throw error;
+    }
+    return Object.freeze({ ready, stop });
+}

package/dist/src/runtime/runtime-host-scheduler-ownership.d.ts

@@ -0,0 +1,5 @@
+import type { RuntimeEnvironmentServices } from "./composition.js";
+export declare function acquireHostScheduler(services: RuntimeEnvironmentServices | undefined): {
+    ready: Promise<void>;
+    release(): Promise<void>;
+};

package/dist/src/runtime/runtime-host-scheduler-ownership.js

@@ -0,0 +1,67 @@
+// Event-only environment wrappers retain this canonical scheduler identity.
+const owners = new WeakMap();
+export function acquireHostScheduler(services) {
+    if (!services) {
+        return { ready: Promise.resolve(), release: async () => { } };
+    }
+    const key = services.scheduler ?? services.startScheduler ?? services;
+    const owner = retainSchedulerOwner(key, services);
+    let released;
+    function release() {
+        if (released)
+            return released;
+        owner.references -= 1;
+        if (hasSchedulerHostReferences(owner)) {
+            released = Promise.resolve();
+            return released;
+        }
+        if (owner.started) {
+            owner.stopping = (async () => {
+                await services?.stopScheduler?.();
+            })();
+        }
+        owner.stopping ??= Promise.resolve();
+        const forgetStoppedOwner = () => {
+            if (owners.get(key) === owner)
+                owners.delete(key);
+        };
+        void owner.stopping.then(forgetStoppedOwner, forgetStoppedOwner);
+        // An abandoned queued start owns no resources and must not wait for its
+        // predecessor. Keep that predecessor's barrier for the next acquisition.
+        released = owner.started ? owner.stopping : Promise.resolve();
+        return released;
+    }
+    return { ready: owner.ready, release };
+}
+function hasSchedulerHostReferences(owner) {
+    return owner.references > 0;
+}
+function retainActiveSchedulerOwner(owner) {
+    if (!owner)
+        return undefined;
+    if (!hasSchedulerHostReferences(owner))
+        return undefined;
+    owner.references += 1;
+    return owner;
+}
+function retainSchedulerOwner(key, services) {
+    const previous = owners.get(key);
+    const retained = retainActiveSchedulerOwner(previous);
+    if (retained)
+        return retained;
+    const owner = {
+        references: 1,
+        started: false,
+        ready: Promise.resolve(),
+        stopping: previous?.stopping,
+    };
+    owners.set(key, owner);
+    const start = async () => {
+        if (!hasSchedulerHostReferences(owner))
+            return;
+        owner.started = true;
+        await services.startScheduler?.();
+    };
+    owner.ready = previous?.stopping ? previous.stopping.then(start) : start();
+    return owner;
+}

package/dist/src/runtime/runtime-host.d.ts

@@ -0,0 +1,19 @@
+import type { RuntimeConfig, RuntimeHost, EventSinkFactory, ModelGatewayClient, SessionStore, ToolRegistry } from "./ports.js";
+import type { RuntimeAttachmentStore } from "./attachments/store.js";
+import type { LongTermMemoryService } from "./long-term-memory/index.js";
+import type { RuntimeEnvironmentServices, RuntimeRequestHandler } from "./composition.js";
+export declare function createDefaultRuntimeHost(config?: RuntimeConfig, defaults?: DefaultRuntimeHostBindings): RuntimeHost;
+export type DefaultRuntimeHostBindings = Readonly<{
+    runtimeId?: string;
+    agentBridgeUrl?: string;
+    agentBridgeToken?: string;
+    eventSinkFactory?: EventSinkFactory;
+    modelGatewayClient?: ModelGatewayClient;
+    sessionStore?: SessionStore;
+    attachmentStore?: RuntimeAttachmentStore;
+    toolRegistry?: ToolRegistry;
+    longTermMemoryService?: LongTermMemoryService;
+    services?: RuntimeEnvironmentServices;
+    requestHandler?: RuntimeRequestHandler;
+    requestHandlerFactory?: (services: RuntimeEnvironmentServices) => RuntimeRequestHandler;
+}>;

package/dist/src/runtime/runtime-host.js

@@ -0,0 +1,63 @@
+import { startAgentBridge } from "../bridge/start-agent-bridge.js";
+import { createDefaultAttachmentStore, createDefaultToolRegistry, } from "./default-environment-adapters.js";
+import { createBoundRuntimeRequestHandler } from "./request/bound-runtime-handler.js";
+import { resolveRuntimeHostEnvironmentServices } from "./runtime-host-environment.js";
+import { startRuntimeHostLifecycle } from "./runtime-host-lifecycle.js";
+export function createDefaultRuntimeHost(config, defaults = {}) {
+    return {
+        start(options = {}) {
+            const services = resolveRuntimeHostEnvironmentServices({
+                config,
+                defaults,
+                options,
+            });
+            const runtimeConfig = services?.config ?? options.runtimeConfig ?? config;
+            const defaultRuntimeConfig = defaults.services?.config ?? config;
+            const runtimeConfigIdentityChanged = runtimeConfig !== undefined && runtimeConfig !== defaultRuntimeConfig;
+            const requestHandler = services
+                ? resolveRuntimeHostRequestHandler(services, defaults)
+                : defaults.requestHandler;
+            return startRuntimeHostLifecycle(services, requestHandler, (readyHandler) => startAgentBridge({
+                runtimeConfig,
+                runtimeId: options.runtimeId ??
+                    (runtimeConfigIdentityChanged
+                        ? runtimeConfig.runtimeId
+                        : defaults.runtimeId),
+                token: options.agentBridgeToken ??
+                    (runtimeConfigIdentityChanged
+                        ? runtimeConfig.agentBridgeToken
+                        : defaults.agentBridgeToken),
+                url: options.agentBridgeUrl ??
+                    (runtimeConfigIdentityChanged
+                        ? runtimeConfig.agentBridgeUrl
+                        : defaults.agentBridgeUrl),
+                eventSinkFactory: services?.events ??
+                    options.eventSinkFactory ??
+                    defaults.eventSinkFactory,
+                modelGatewayClient: services?.models ??
+                    options.modelGatewayClient ??
+                    defaults.modelGatewayClient,
+                sessionStore: services?.sessions ??
+                    options.sessionStore ??
+                    defaults.sessionStore,
+                attachmentStore: services?.attachments ??
+                    options.attachmentStore ??
+                    defaults.attachmentStore ??
+                    (runtimeConfig
+                        ? createDefaultAttachmentStore(runtimeConfig)
+                        : undefined),
+                toolRegistry: services?.tools ??
+                    options.toolRegistry ??
+                    defaults.toolRegistry ??
+                    createDefaultToolRegistry(runtimeConfig),
+                requestHandler: readyHandler,
+            }));
+        },
+    };
+}
+function resolveRuntimeHostRequestHandler(services, defaults) {
+    if (services === defaults.services && defaults.requestHandler) {
+        return defaults.requestHandler;
+    }
+    return (defaults.requestHandlerFactory ?? createBoundRuntimeRequestHandler)(services);
+}

package/dist/src/runtime/scheduler/calendar-time.d.ts

@@ -0,0 +1,10 @@
+export interface CalendarDate {
+    year: number;
+    month: number;
+    day: number;
+}
+export declare function calendarDateAt(instant: number, timeZone: string): CalendarDate;
+export declare function addCalendarDays(date: CalendarDate, days: number): CalendarDate;
+export declare function calendarWeekday(date: CalendarDate): number;
+/** Missing wall times are skipped; repeated wall times select the first occurrence. */
+export declare function resolveCalendarTime(date: CalendarDate, at: string, timeZone: string): number | null;

package/dist/src/runtime/scheduler/calendar-time.js

@@ -0,0 +1,58 @@
+function calendarFormatter(timeZone) {
+    return new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hourCycle: "h23",
+    });
+}
+function readCalendarParts(formatter, instant) {
+    const parts = Object.fromEntries(formatter.formatToParts(instant).map((part) => [part.type, part.value]));
+    return {
+        year: Number(parts.year),
+        month: Number(parts.month),
+        day: Number(parts.day),
+        hour: Number(parts.hour),
+        minute: Number(parts.minute),
+        second: Number(parts.second),
+    };
+}
+function calendarPartsAsUtc(parts) {
+    return Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+}
+export function calendarDateAt(instant, timeZone) {
+    const { year, month, day } = readCalendarParts(calendarFormatter(timeZone), instant);
+    return { year, month, day };
+}
+export function addCalendarDays(date, days) {
+    const next = new Date(Date.UTC(date.year, date.month - 1, date.day + days));
+    return {
+        year: next.getUTCFullYear(),
+        month: next.getUTCMonth() + 1,
+        day: next.getUTCDate(),
+    };
+}
+export function calendarWeekday(date) {
+    return new Date(Date.UTC(date.year, date.month - 1, date.day)).getUTCDay();
+}
+/** Missing wall times are skipped; repeated wall times select the first occurrence. */
+export function resolveCalendarTime(date, at, timeZone) {
+    const [hour, minute] = at.split(":").map(Number);
+    const wanted = Date.UTC(date.year, date.month - 1, date.day, hour, minute);
+    const formatter = calendarFormatter(timeZone);
+    const offsets = new Set();
+    // Both sides of a transition are observed, including half-hour and date-line changes.
+    for (let hours = -36; hours <= 36; hours += 6) {
+        const probe = wanted + hours * 3_600_000;
+        offsets.add(calendarPartsAsUtc(readCalendarParts(formatter, probe)) - probe);
+    }
+    const candidates = [...offsets]
+        .map((offset) => wanted - offset)
+        .filter((instant) => calendarPartsAsUtc(readCalendarParts(formatter, instant)) === wanted)
+        .sort((a, b) => a - b);
+    return candidates[0] ?? null;
+}