paperkite 0.1.0

package/dist/src/engine/runtime.js

@@ -0,0 +1,799 @@
+import { SessionUnavailableError } from "@paperkite/sdk";
+import { basename, join } from "node:path";
+import { updateFlowItem } from "../config/loader.js";
+import { AppLogger } from "./logger.js";
+import { invalidateAllHooks, invalidateHook, loadHook } from "./hooks.js";
+import { RuntimeScheduler } from "./scheduler.js";
+import { CapabilityRegistry } from "../extensions/registry.js";
+export class Runtime {
+    options;
+    static DEFAULT_STOP_GRACE_MS = 10_000;
+    scheduler = new RuntimeScheduler();
+    controllers = new Map();
+    runs = new Map();
+    tasks = new Set();
+    listeners = new Set();
+    serviceStartedAt = new Map();
+    activeActionEntries = new Map();
+    suspended = new Map();
+    catalog;
+    lifecycle = new AbortController();
+    started = false;
+    startedAt = 0;
+    stopping;
+    reloading;
+    constructor(options) {
+        this.options = options;
+        this.catalog = options.catalog;
+        this.sessionUnsub = options.sessions.subscribe((change) => this.handleSessionChange(change));
+    }
+    sessionUnsub;
+    get snapshot() {
+        return {
+            running: this.started,
+            pid: process.pid,
+            uptimeSeconds: this.started ? (Date.now() - this.startedAt) / 1000 : 0,
+            triggers: this.catalog.enabled("trigger").map((item) => item.id),
+            services: this.catalog.enabled("service").map((item) => item.id),
+            schedules: this.catalog.enabled("schedule").map((item) => item.id),
+            activeServices: [...this.controllers.keys()]
+                .filter((key) => key.startsWith("service:"))
+                .map((key) => key.slice("service:".length)),
+            activeActions: [...this.activeActionEntries.values()].map((entry) => ({
+                id: entry.id,
+                capability: entry.capability,
+                session: entry.session,
+                flow: entry.flow,
+                startedAt: new Date(entry.startedAt).toISOString()
+            })),
+            flows: this.catalog.definitions().map((item) => this.flowSnapshot(item)),
+            sessions: this.sessionSnapshots(),
+            logs: this.logScopes()
+        };
+    }
+    listPlugins() {
+        return this.options.installed;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    async start() {
+        if (this.started)
+            return;
+        await this.settleStopping();
+        if (this.lifecycle.signal.aborted)
+            this.lifecycle = new AbortController();
+        const sessions = collectSessions(this.catalog);
+        try {
+            if (sessions.size)
+                await this.options.sessions.ensure(sessions);
+            this.started = true;
+            this.startedAt = Date.now();
+            this.startFlows();
+            for (const info of this.options.sessions.states()) {
+                if (info.state === "waiting-auth") {
+                    this.options.logger.warn("session " + info.name + " is waiting for login; run `paperkite session login " + info.name + "` to log in");
+                }
+            }
+        }
+        catch (error) {
+            this.started = false;
+            this.lifecycle.abort();
+            await this.stopFlows();
+            await this.options.sessions.closeAll();
+            throw error;
+        }
+    }
+    async reload() {
+        if (this.reloading)
+            return this.reloading;
+        const reloading = this.performReload();
+        this.reloading = reloading;
+        try {
+            await reloading;
+        }
+        finally {
+            if (this.reloading === reloading)
+                this.reloading = undefined;
+        }
+    }
+    async performReload() {
+        await this.settleStopping();
+        if (!this.options.reloadCatalog)
+            throw new Error("config reload is not configured");
+        this.emit({ type: "flows.reloading" });
+        let next;
+        try {
+            next = await this.options.reloadCatalog();
+        }
+        catch (error) {
+            this.emit({ type: "flows.reloaded", ok: false, error: messageOf(error) });
+            throw error;
+        }
+        const wasStarted = this.started;
+        await this.stopFlows();
+        this.catalog = next;
+        invalidateAllHooks();
+        if (wasStarted) {
+            const sessions = collectSessions(this.catalog);
+            if (sessions.size)
+                await this.options.sessions.ensure(sessions);
+            this.startFlows();
+        }
+        this.emit({ type: "flows.reloaded", ok: true });
+    }
+    async executeAction(spec, flow) {
+        const capability = String(spec.capability ?? "").trim();
+        if (!capability)
+            throw new Error("executeAction needs capability");
+        const action = {
+            capability,
+            config: spec.config ?? {},
+            session: spec.session,
+            hook: spec.hook
+        };
+        const sessions = collectActionSessions(action);
+        if (sessions.size)
+            await this.options.sessions.ensure(sessions);
+        await this.runAction(action, spec.label ?? `action:${capability}`, undefined, spec.session, this.lifecycle.signal, flow);
+    }
+    async runFlow(identifier) {
+        const command = this.catalog.find(identifier, "command");
+        const definition = command ?? this.catalog.find(identifier, "schedule");
+        if (!definition || (definition.kind !== "command" && definition.kind !== "schedule")) {
+            throw new Error("unknown flow: " + identifier);
+        }
+        if (definition.kind === "schedule" && !definition.enabled) {
+            throw new Error("schedule is disabled: " + definition.id);
+        }
+        if (definition.kind === "command")
+            this.invalidateFlowHooks(definition);
+        const action = {
+            ...definition.action,
+            session: definition.action.session ?? (definition.kind === "schedule" ? definition.session : undefined)
+        };
+        await this.completeFlow(definition.kind, definition.id, action.capability, () => this.executeAction({ ...action, label: `${definition.kind}:${definition.id}` }, { kind: definition.kind, id: definition.id }));
+    }
+    async completeFlow(kind, id, capability, operation) {
+        const startedAt = Date.now();
+        try {
+            await operation();
+        }
+        catch (error) {
+            this.emit({ type: "flow.finished", kind, id, capability, ok: false, durationMs: Date.now() - startedAt });
+            throw error;
+        }
+        this.emit({ type: "flow.finished", kind, id, capability, ok: true, durationMs: Date.now() - startedAt });
+    }
+    async startService(identifier) {
+        await this.settleStopping();
+        if (this.lifecycle.signal.aborted)
+            this.lifecycle = new AbortController();
+        const definition = this.catalog.find(identifier, "service");
+        if (!definition || definition.kind !== "service")
+            throw new Error("unknown service: " + identifier);
+        if (!definition.enabled)
+            throw new Error("service is disabled: " + definition.id);
+        if (this.controllers.has(`service:${definition.id}`))
+            return;
+        const gate = this.boundSession(definition);
+        const state = this.sessionState(gate);
+        if (gate && state !== undefined && state !== "connected") {
+            throw new SessionUnavailableError(gate, state, this.sessionReason(gate));
+        }
+        const sessions = new Set();
+        if (definition.session)
+            sessions.add(definition.session);
+        if (sessions.size)
+            await this.options.sessions.ensure(sessions);
+        this.launchService(definition);
+    }
+    async reconnectSession(name) {
+        await this.options.sessions.reconnectSession(name);
+    }
+    async stopService(identifier) {
+        const definition = this.catalog.find(identifier, "service");
+        if (!definition || definition.kind !== "service")
+            throw new Error("unknown service: " + identifier);
+        await this.stopFlow(`service:${definition.id}`);
+    }
+    async updateFlow(identifier, patch) {
+        const next = await updateFlowItem(this.catalog, identifier, patch);
+        if (!next)
+            return false;
+        this.catalog = next;
+        const item = next.find(identifier);
+        if (item)
+            this.emit({ type: "flow.updated", id: item.id, kind: item.kind });
+        return true;
+    }
+    async reloadFlow(identifier) {
+        const item = this.catalog.find(identifier);
+        if (!item)
+            return false;
+        this.invalidateFlowHooks(item);
+        if (item.kind === "schedule") {
+            this.scheduler.remove(item.id);
+            if (this.started && item.enabled)
+                this.startSchedule(item);
+        }
+        else if (item.kind === "trigger") {
+            await this.stopFlow(`trigger:${item.id}`);
+            if (this.started && item.enabled)
+                this.startTrigger(item);
+        }
+        else if (item.kind === "service") {
+            await this.stopFlow(`service:${item.id}`);
+            if (this.started && item.enabled && item.autoStart)
+                this.launchService(item);
+        }
+        this.emit({ type: "flow.reloaded", id: item.id, kind: item.kind });
+        return true;
+    }
+    invalidateFlowHooks(item) {
+        const references = item.kind === "trigger"
+            ? item.actions.map((action) => action.hook)
+            : "action" in item
+                ? [item.action.hook]
+                : [];
+        for (const reference of references)
+            invalidateHook(reference, this.catalog.path);
+    }
+    async stop() {
+        if (this.stopping)
+            return this.stopping;
+        const stopping = (async () => {
+            this.started = false;
+            this.lifecycle.abort();
+            await this.stopFlows();
+            await this.options.sessions.closeAll();
+        })();
+        this.stopping = stopping;
+        await stopping;
+        if (this.stopping === stopping)
+            this.stopping = undefined;
+    }
+    async settleStopping() {
+        const previousStop = this.stopping;
+        if (previousStop) {
+            await previousStop;
+            if (this.stopping === previousStop)
+                this.stopping = undefined;
+        }
+    }
+    async stopFlows() {
+        this.scheduler.stopAll();
+        const running = [...this.runs.entries()];
+        for (const controller of this.controllers.values())
+            controller.abort();
+        this.controllers.clear();
+        this.suspended.clear();
+        const tasks = [...this.tasks];
+        if (tasks.length) {
+            const graceMs = this.stopGraceMs();
+            const pending = await settleWithin(tasks, graceMs);
+            if (pending > 0) {
+                const leftovers = await stillRunning(running);
+                const names = leftovers.length ? leftovers.join(", ") : `${pending} unknown`;
+                this.options.logger.warn(`${pending} flow task(s) did not stop within ${graceMs}ms and keep running: ${names}`);
+            }
+        }
+        this.runs.clear();
+    }
+    async stopFlow(key) {
+        const controller = this.controllers.get(key);
+        const run = this.runs.get(key);
+        this.clearSuspension(key);
+        if (!controller && !run)
+            return;
+        controller?.abort();
+        if (run)
+            await settleWithin([run], this.stopGraceMs());
+    }
+    stopGraceMs() {
+        return this.options.stopGraceMs ?? Runtime.DEFAULT_STOP_GRACE_MS;
+    }
+    startFlows() {
+        for (const definition of this.catalog.enabled("trigger")) {
+            if (definition.kind !== "trigger")
+                continue;
+            if (this.flowBlocked(definition))
+                continue;
+            this.startTrigger(definition);
+        }
+        for (const definition of this.catalog.enabled("service")) {
+            if (definition.kind !== "service")
+                continue;
+            if (!definition.autoStart)
+                continue;
+            if (this.flowBlocked(definition))
+                continue;
+            this.launchService(definition);
+        }
+        for (const definition of this.catalog.enabled("schedule")) {
+            if (definition.kind !== "schedule")
+                continue;
+            if (this.flowBlocked(definition))
+                continue;
+            this.startSchedule(definition);
+        }
+    }
+    flowBlocked(definition) {
+        const session = this.boundSession(definition);
+        const state = this.sessionState(session);
+        if (!session || state === undefined || state === "connected")
+            return false;
+        this.recordSuspension(definition, session, this.sessionReason(session));
+        return true;
+    }
+    async handleSessionChange(change) {
+        this.emit({
+            type: "session.state",
+            name: change.name,
+            state: change.state,
+            reason: change.reason,
+            since: new Date().toISOString()
+        });
+        if (!this.started)
+            return;
+        if (change.state === "connected") {
+            this.resumeForSession(change.name);
+            return;
+        }
+        this.suspendForSession(change.name, change.reason);
+    }
+    suspendForSession(name, error) {
+        for (const definition of this.catalog.definitions()) {
+            if (definition.kind === "command")
+                continue;
+            const session = this.boundSession(definition);
+            if (session !== name)
+                continue;
+            const key = `${definition.kind}:${definition.id}`;
+            if (this.suspended.has(key))
+                continue;
+            if (definition.kind === "schedule") {
+                if (!this.scheduler.has(definition.id))
+                    continue;
+                this.scheduler.remove(definition.id);
+            }
+            else {
+                const controller = this.controllers.get(key);
+                if (!controller)
+                    continue;
+                controller.abort();
+            }
+            this.recordSuspension(definition, name, error);
+            this.emit({ type: "flow.suspended", id: definition.id, kind: definition.kind, session: name, error });
+        }
+    }
+    resumeForSession(name) {
+        for (const [key, suspension] of [...this.suspended.entries()]) {
+            if (suspension.session !== name)
+                continue;
+            this.suspended.delete(key);
+            const separator = key.indexOf(":");
+            const kind = key.slice(0, separator);
+            const definition = this.catalog.find(key.slice(separator + 1), kind);
+            if (!definition)
+                continue;
+            if (definition.kind !== "command" && !definition.enabled)
+                continue;
+            if (definition.kind === "schedule") {
+                this.startSchedule(definition);
+            }
+            else if (definition.kind === "service") {
+                this.launchService(definition);
+            }
+            else if (definition.kind === "trigger") {
+                this.startTrigger(definition);
+            }
+            else {
+                continue;
+            }
+            this.emit({ type: "flow.resumed", id: definition.id, kind: definition.kind, session: name });
+        }
+    }
+    recordSuspension(definition, session, error) {
+        this.suspended.set(`${definition.kind}:${definition.id}`, { kind: definition.kind, id: definition.id, session, error, since: Date.now() });
+    }
+    clearSuspension(key) {
+        this.suspended.delete(key);
+    }
+    startTrigger(definition) {
+        const key = `trigger:${definition.id}`;
+        const controller = new AbortController();
+        this.controllers.set(key, controller);
+        const task = this.runTrigger(definition, controller).catch((error) => {
+            if (!controller.signal.aborted)
+                this.options.logger.error("trigger stopped: " + definition.id, error);
+        }).finally(() => {
+            if (this.controllers.get(key) === controller)
+                this.controllers.delete(key);
+            if (this.runs.get(key) === task)
+                this.runs.delete(key);
+        });
+        this.runs.set(key, task);
+        this.track(task);
+    }
+    launchService(definition) {
+        const key = `service:${definition.id}`;
+        const controller = new AbortController();
+        this.controllers.set(key, controller);
+        this.serviceStartedAt.set(key, Date.now());
+        let failure;
+        const task = this.runService(definition, controller).catch((error) => {
+            failure = error;
+            if (!controller.signal.aborted)
+                this.options.logger.error("service stopped: " + definition.id, error);
+        }).finally(() => {
+            if (this.controllers.get(key) === controller)
+                this.controllers.delete(key);
+            if (this.runs.get(key) === task)
+                this.runs.delete(key);
+            const startedAt = this.serviceStartedAt.get(key);
+            this.serviceStartedAt.delete(key);
+            this.emit({
+                type: "service.stopped",
+                id: definition.id,
+                capability: definition.capability,
+                session: definition.session,
+                reason: failure !== undefined ? "error" : controller.signal.aborted ? "stop" : "finished",
+                error: failure instanceof Error ? failure.message : undefined,
+                durationMs: startedAt === undefined ? 0 : Date.now() - startedAt
+            });
+        });
+        this.runs.set(key, task);
+        this.track(task);
+        this.emit({
+            type: "service.started",
+            id: definition.id,
+            capability: definition.capability,
+            session: definition.session
+        });
+    }
+    startSchedule(definition) {
+        this.scheduler.add(definition, () => {
+            const task = this.completeFlow("schedule", definition.id, definition.action.capability, () => this.runAction(definition.action, `schedule:${definition.id}`, undefined, definition.session, this.scheduleSignal, { kind: "schedule", id: definition.id })).catch((error) => this.options.logger.error("schedule failed: " + definition.id, error));
+            this.track(task);
+            return task;
+        }, this.scheduleSignal, (item) => this.emit({
+            type: "schedule.fired",
+            id: item.id,
+            cron: item.cron,
+            intervalSeconds: item.intervalSeconds
+        }));
+    }
+    get scheduleSignal() {
+        return this.lifecycle.signal;
+    }
+    async runTrigger(definition, controller) {
+        const Constructor = this.options.registry.getTrigger(definition.capability);
+        let emitted = 0;
+        const context = {
+            id: definition.id,
+            capability: definition.capability,
+            config: definition.config,
+            session: definition.session,
+            signal: controller.signal,
+            sessions: this.options.sessions.access(definition.session),
+            control: this.options.registry.grantsControl("trigger", definition.capability) ? this : undefined,
+            logger: this.capabilityLogger("trigger", definition.capability),
+            maxRuns: definition.maxRuns,
+            emit: async (event) => {
+                if (controller.signal.aborted)
+                    return;
+                emitted += 1;
+                const emission = {
+                    source: { id: definition.id, capability: definition.capability },
+                    event
+                };
+                const startedAt = Date.now();
+                let ok = true;
+                try {
+                    for (const [index, action] of definition.actions.entries()) {
+                        const outcome = await this.runAction(action, `trigger:${definition.id}:${index + 1}`, emission, action.session ?? definition.session, controller.signal, { kind: "trigger", id: definition.id }, true);
+                        if (outcome.skipped)
+                            ok = false;
+                    }
+                }
+                catch (error) {
+                    this.emit({
+                        type: "flow.finished",
+                        kind: "trigger",
+                        id: definition.id,
+                        capability: definition.capability,
+                        ok: false,
+                        durationMs: Date.now() - startedAt
+                    });
+                    throw error;
+                }
+                this.emit({
+                    type: "flow.finished",
+                    kind: "trigger",
+                    id: definition.id,
+                    capability: definition.capability,
+                    ok,
+                    durationMs: Date.now() - startedAt
+                });
+                if (definition.maxRuns && emitted >= definition.maxRuns)
+                    controller.abort();
+            }
+        };
+        const trigger = new Constructor(context);
+        await trigger.run();
+    }
+    async runService(definition, controller) {
+        const Constructor = this.options.registry.getService(definition.capability);
+        const context = {
+            id: definition.id,
+            capability: definition.capability,
+            config: definition.config,
+            session: definition.session,
+            signal: controller.signal,
+            sessions: this.options.sessions.access(definition.session),
+            control: this.options.registry.grantsControl("service", definition.capability) ? this : undefined,
+            logger: this.capabilityLogger("service", definition.capability)
+        };
+        await new Constructor(context).run();
+    }
+    async runAction(specification, id, emission, parentSession, signal, flow, soft = false) {
+        const capability = specification.capability;
+        const session = specification.session ?? parentSession;
+        const state = this.sessionState(session);
+        if (session && state !== undefined && state !== "connected") {
+            const error = new SessionUnavailableError(session, state, this.sessionReason(session));
+            if (soft) {
+                this.emit({
+                    type: "action.finished",
+                    id,
+                    capability,
+                    session,
+                    flow,
+                    ok: false,
+                    skipped: false,
+                    durationMs: 0,
+                    error: error.message
+                });
+                return { skipped: true };
+            }
+            throw error;
+        }
+        const Constructor = this.options.registry.getAction(capability);
+        const hook = await loadHook(specification.hook, this.catalog.path);
+        const context = {
+            id,
+            config: specification.config,
+            session,
+            signal,
+            sessions: this.options.sessions.access(session),
+            control: this.options.registry.grantsControl("action", capability) ? this : undefined,
+            logger: this.capabilityLogger("action", capability),
+            emission,
+            hook,
+            outcome: undefined,
+            spawn: (task) => this.track(task.then(() => undefined))
+        };
+        const startedAt = Date.now();
+        this.activeActionEntries.set(id, { id, capability, session, flow, startedAt });
+        this.emit({
+            type: "action.started",
+            id,
+            capability,
+            session,
+            flow,
+            hook: specification.hook,
+            config: exportable(specification.config)
+        });
+        let failure;
+        try {
+            await new Constructor(context).execute();
+        }
+        catch (error) {
+            failure = error;
+            throw error;
+        }
+        finally {
+            this.activeActionEntries.delete(id);
+            this.emit({
+                type: "action.finished",
+                id,
+                capability,
+                session,
+                flow,
+                ok: failure === undefined,
+                skipped: context.outcome?.skipped === true,
+                durationMs: Date.now() - startedAt,
+                error: failure instanceof Error ? failure.message : failure === undefined ? undefined : String(failure),
+                effectiveConfig: exportable(context.outcome?.effectiveConfig)
+            });
+        }
+        return { skipped: false };
+    }
+    capabilityLogger(kind, capability) {
+        const scope = this.options.registry.scopeOf(kind, capability) ?? capability;
+        return this.options.logger.child(scope);
+    }
+    flowSnapshot(definition) {
+        const base = {
+            kind: definition.kind,
+            id: definition.id,
+            capability: "capability" in definition ? definition.capability : definition.action.capability,
+            enabled: definition.kind === "command" ? true : definition.enabled,
+            active: definition.kind === "service" || definition.kind === "trigger"
+                ? this.controllers.has(`${definition.kind}:${definition.id}`)
+                : false,
+            session: "session" in definition ? definition.session : undefined,
+            logFile: "logFile" in definition ? definition.logFile : false,
+            suspended: this.suspensionOf(definition)
+        };
+        if (definition.kind === "trigger") {
+            return {
+                ...base,
+                maxRuns: definition.maxRuns,
+                config: copyOf(definition.config),
+                actions: definition.actions.map((action) => actionView(action))
+            };
+        }
+        if (definition.kind === "service") {
+            return {
+                ...base,
+                autoStart: definition.autoStart,
+                config: copyOf(definition.config),
+                startedAt: this.serviceStartedAt.get(`service:${definition.id}`) === undefined
+                    ? undefined
+                    : new Date(this.serviceStartedAt.get(`service:${definition.id}`)).toISOString()
+            };
+        }
+        return {
+            ...base,
+            title: definition.kind === "command" ? definition.title : undefined,
+            symbol: definition.kind === "command" ? definition.symbol : undefined,
+            cron: definition.kind === "schedule" ? definition.cron : undefined,
+            intervalSeconds: definition.kind === "schedule" ? definition.intervalSeconds : undefined,
+            actionSession: definition.action.session,
+            hook: definition.action.hook,
+            config: copyOf(definition.action.config)
+        };
+    }
+    suspensionOf(definition) {
+        const suspension = this.suspended.get(`${definition.kind}:${definition.id}`);
+        if (!suspension)
+            return undefined;
+        return {
+            since: new Date(suspension.since).toISOString(),
+            reason: "session",
+            session: suspension.session,
+            error: suspension.error
+        };
+    }
+    sessionSnapshots() {
+        const states = this.options.sessions.states();
+        return states.map((info) => ({
+            name: info.name,
+            state: info.state,
+            since: new Date(info.since).toISOString(),
+            reason: info.reason,
+            attempts: info.attempts,
+            flows: [...this.suspended.values()]
+                .filter((item) => item.session === info.name)
+                .map((item) => ({ kind: item.kind, id: item.id }))
+        }));
+    }
+    sessionState(name) {
+        if (!name)
+            return undefined;
+        return this.options.sessions.state(name);
+    }
+    sessionReason(name) {
+        return this.options.sessions.states().find((info) => info.name === name)?.reason;
+    }
+    boundSession(definition) {
+        if (definition.kind === "command")
+            return definition.action.session;
+        if (definition.kind === "schedule")
+            return definition.action.session ?? definition.session;
+        return definition.session;
+    }
+    logScopes() {
+        const directory = this.options.logger.logDirectory();
+        if (!directory)
+            return [];
+        const scopes = ["paperkite", ...this.options.logger.registeredScopes()];
+        return scopes.map((scope) => ({ scope, path: join(directory, basename(scope) + ".log") }));
+    }
+    emit(event) {
+        const withAt = { ...event, at: new Date().toISOString() };
+        for (const listener of [...this.listeners]) {
+            try {
+                listener(withAt);
+            }
+            catch (error) {
+                this.options.logger.error("runtime event listener failed", error);
+            }
+        }
+    }
+    track(task) {
+        const observed = task.catch((error) => {
+            this.options.logger.error("background task failed", error);
+        });
+        this.tasks.add(observed);
+        void observed.then(() => this.tasks.delete(observed));
+    }
+}
+function collectSessions(catalog) {
+    const names = new Set();
+    for (const definition of catalog.enabled()) {
+        if ("session" in definition && definition.session)
+            names.add(definition.session);
+        if (definition.kind === "trigger") {
+            for (const action of definition.actions)
+                collectActionSessions(action, names);
+        }
+        else if (definition.kind === "command" || definition.kind === "schedule") {
+            collectActionSessions(definition.action, names);
+        }
+    }
+    return names;
+}
+function collectActionSessions(action, names = new Set()) {
+    if (action.session)
+        names.add(action.session);
+    return names;
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function settleWithin(tasks, milliseconds) {
+    let pending = tasks.length;
+    const observed = tasks.map((task) => task.then(() => {
+        pending -= 1;
+    }, () => {
+        pending -= 1;
+    }));
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(resolve, milliseconds);
+    });
+    try {
+        await Promise.race([Promise.allSettled(observed), timeout]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+    return pending;
+}
+async function stillRunning(entries) {
+    const keys = [];
+    for (const [key, task] of entries) {
+        const settled = await Promise.race([
+            task.then(() => true, () => true),
+            new Promise((resolve) => queueMicrotask(() => resolve(false)))
+        ]);
+        if (!settled)
+            keys.push(key);
+    }
+    return keys;
+}
+function actionView(action) {
+    return { capability: action.capability, session: action.session, config: copyOf(action.config), hook: action.hook };
+}
+function exportable(value) {
+    if (value === undefined)
+        return undefined;
+    try {
+        const text = JSON.stringify(value);
+        if (!text || text.length > 4096)
+            return undefined;
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function copyOf(value) {
+    return structuredClone(value);
+}
+//# sourceMappingURL=runtime.js.map