@nodetool-ai/websocket 0.7.0-rc.23 → 0.8.1

package/dist/triggers/schedule-timing.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Schedule timing — the one place `schedule` registrations are turned into
+ * instants.
+ *
+ * The scheduler sweep (`scheduler.ts`) and the editor's "next fire" readout
+ * (`trpc/routers/triggers.ts`) need the same arithmetic: when is this
+ * registration next due, given `created_at`, `last_fired_at` and the
+ * `config_json` keys `IntervalTriggerNode` snapshots on sync. Computing it
+ * twice would let the displayed time drift away from the time the sweep
+ * actually fires at, so both callers go through `computeScheduleTiming`.
+ *
+ * The result is derived purely from persisted state — no wall clock — which is
+ * what makes the scheduler's `input_id` reproducible across a crash between
+ * delivering an input and persisting the new `last_fired_at`.
+ *
+ * `include_drift_compensation` is deliberately not read here: it is an
+ * in-process concern of `IntervalTriggerNode`'s own loop. The host schedules
+ * from the last fire, so a slow sweep shifts the next tick rather than
+ * catching up on missed ones.
+ */
+import type { TriggerRegistration } from "@nodetool-ai/models";
+/** The registration kind whose `last_fired_at` doubles as the sweep cursor. */
+export declare const SCHEDULE_KIND = "schedule";
+export declare const DEFAULT_INTERVAL_SECONDS = 60;
+interface ScheduleTiming {
+    /** `interval_seconds` from config, or the 60s default. */
+    intervalSeconds: number;
+    /** The same interval in milliseconds, floored at 1ms. */
+    intervalMs: number;
+    /** Epoch ms of the next instant this registration is due to fire. */
+    nextFireAtMs: number;
+}
+/**
+ * The next due instant for a `schedule` registration, honoring
+ * `interval_seconds` (default 60), `initial_delay_seconds` (default 0), and
+ * `emit_on_start` (default true) from `config_json`.
+ *
+ * Returns `null` when `created_at` is unparseable — the registration has no
+ * anchor to schedule from.
+ */
+export declare function computeScheduleTiming(registration: TriggerRegistration): ScheduleTiming | null;
+/**
+ * The next fire instant as ISO 8601, or `null` when the registration is not a
+ * schedule, is disabled, or has no schedulable anchor. This is the value the
+ * editor renders; it can be in the past for a registration the sweep has not
+ * caught up with yet.
+ */
+export declare function nextFireAtIso(registration: TriggerRegistration): string | null;
+/** `interval_seconds` for a schedule registration, `null` for other kinds. */
+export declare function scheduleIntervalSeconds(registration: TriggerRegistration): number | null;
+export {};
+//# sourceMappingURL=schedule-timing.d.ts.map

package/dist/triggers/schedule-timing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule-timing.d.ts","sourceRoot":"","sources":["../../src/triggers/schedule-timing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/D,+EAA+E;AAC/E,eAAO,MAAM,aAAa,aAAa,CAAC;AAExC,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAE3C,UAAU,cAAc;IACtB,0DAA0D;IAC1D,eAAe,EAAE,MAAM,CAAC;IACxB,yDAAyD;IACzD,UAAU,EAAE,MAAM,CAAC;IACnB,qEAAqE;IACrE,YAAY,EAAE,MAAM,CAAC;CACtB;AAsBD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,mBAAmB,GAChC,cAAc,GAAG,IAAI,CAgCvB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,YAAY,EAAE,mBAAmB,GAAG,MAAM,GAAG,IAAI,CAM9E;AAED,8EAA8E;AAC9E,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,mBAAmB,GAChC,MAAM,GAAG,IAAI,CAOf"}

package/dist/triggers/schedule-timing.js

@@ -0,0 +1,90 @@
+/**
+ * Schedule timing — the one place `schedule` registrations are turned into
+ * instants.
+ *
+ * The scheduler sweep (`scheduler.ts`) and the editor's "next fire" readout
+ * (`trpc/routers/triggers.ts`) need the same arithmetic: when is this
+ * registration next due, given `created_at`, `last_fired_at` and the
+ * `config_json` keys `IntervalTriggerNode` snapshots on sync. Computing it
+ * twice would let the displayed time drift away from the time the sweep
+ * actually fires at, so both callers go through `computeScheduleTiming`.
+ *
+ * The result is derived purely from persisted state — no wall clock — which is
+ * what makes the scheduler's `input_id` reproducible across a crash between
+ * delivering an input and persisting the new `last_fired_at`.
+ *
+ * `include_drift_compensation` is deliberately not read here: it is an
+ * in-process concern of `IntervalTriggerNode`'s own loop. The host schedules
+ * from the last fire, so a slow sweep shifts the next tick rather than
+ * catching up on missed ones.
+ */
+/** The registration kind whose `last_fired_at` doubles as the sweep cursor. */
+export const SCHEDULE_KIND = "schedule";
+export const DEFAULT_INTERVAL_SECONDS = 60;
+function readNumber(config, key, fallback) {
+    const raw = config?.[key];
+    if (raw === undefined || raw === null)
+        return fallback;
+    const value = Number(raw);
+    return Number.isFinite(value) ? value : fallback;
+}
+function readBool(config, key, fallback) {
+    const raw = config?.[key];
+    return raw === undefined || raw === null ? fallback : Boolean(raw);
+}
+/**
+ * The next due instant for a `schedule` registration, honoring
+ * `interval_seconds` (default 60), `initial_delay_seconds` (default 0), and
+ * `emit_on_start` (default true) from `config_json`.
+ *
+ * Returns `null` when `created_at` is unparseable — the registration has no
+ * anchor to schedule from.
+ */
+export function computeScheduleTiming(registration) {
+    const config = registration.config_json;
+    const intervalSeconds = readNumber(config, "interval_seconds", DEFAULT_INTERVAL_SECONDS);
+    const intervalMs = Math.max(1, intervalSeconds * 1000);
+    if (registration.last_fired_at) {
+        const lastFiredMs = Date.parse(registration.last_fired_at);
+        if (Number.isFinite(lastFiredMs)) {
+            return {
+                intervalSeconds,
+                intervalMs,
+                nextFireAtMs: lastFiredMs + intervalMs
+            };
+        }
+    }
+    const createdAtMs = Date.parse(registration.created_at);
+    if (!Number.isFinite(createdAtMs))
+        return null;
+    const initialDelaySeconds = readNumber(config, "initial_delay_seconds", 0);
+    const emitOnStart = readBool(config, "emit_on_start", true);
+    return {
+        intervalSeconds,
+        intervalMs,
+        nextFireAtMs: createdAtMs + initialDelaySeconds * 1000 + (emitOnStart ? 0 : intervalMs)
+    };
+}
+/**
+ * The next fire instant as ISO 8601, or `null` when the registration is not a
+ * schedule, is disabled, or has no schedulable anchor. This is the value the
+ * editor renders; it can be in the past for a registration the sweep has not
+ * caught up with yet.
+ */
+export function nextFireAtIso(registration) {
+    if (registration.kind !== SCHEDULE_KIND)
+        return null;
+    if (registration.enabled !== 1)
+        return null;
+    const timing = computeScheduleTiming(registration);
+    if (!timing)
+        return null;
+    return new Date(timing.nextFireAtMs).toISOString();
+}
+/** `interval_seconds` for a schedule registration, `null` for other kinds. */
+export function scheduleIntervalSeconds(registration) {
+    if (registration.kind !== SCHEDULE_KIND)
+        return null;
+    return readNumber(registration.config_json, "interval_seconds", DEFAULT_INTERVAL_SECONDS);
+}
+//# sourceMappingURL=schedule-timing.js.map

package/dist/triggers/schedule-timing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule-timing.js","sourceRoot":"","sources":["../../src/triggers/schedule-timing.ts"],"names":[],"mappings":"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"}

package/dist/triggers/scheduler.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Scheduler adapter — the host-owned ingestion adapter for `schedule`
+ * registrations (compiled from `IntervalTriggerNode`s, see
+ * `registration-sync.ts`).
+ *
+ * One coarse sweep timer (not one `setTimeout` per registration) re-reads
+ * enabled `schedule` registrations every tick and delivers a synthesized
+ * "tick" event for every one that is due, via `TriggerWakeupService`. This
+ * mirrors `@nodetool-ai/compute`'s `startReaper` shape: a single interval
+ * timer, an injectable clock, and a stop handle.
+ *
+ * Due-ness and the derived `input_id` are computed purely from persisted
+ * state (`created_at`, `last_fired_at`, `config_json`) and the current sweep
+ * time, so re-running the computation before `last_fired_at` is advanced —
+ * e.g. a process crash between delivering the input and persisting the new
+ * `last_fired_at` — reproduces the exact same `input_id` on the next sweep.
+ * `deliverTriggerInput`'s idempotency-by-`inputId` then makes that replay a
+ * no-op instead of a double-fire.
+ */
+import type { TriggerWakeupService } from "@nodetool-ai/kernel";
+/** Fired once per registration each time a sweep delivers a new tick. */
+interface SchedulerNotifyEvent {
+    registrationId: string;
+    inputId: string;
+}
+interface StartSchedulerOptions {
+    wakeupService: TriggerWakeupService;
+    /** Same-process dispatch hint — called after a new tick is delivered. */
+    notify?: (event: SchedulerNotifyEvent) => void;
+    /** Sweep period. Defaults to 5s — coarse on purpose (see module docs). */
+    intervalMs?: number;
+    /** Injectable clock for deterministic tests. Defaults to `Date.now`. */
+    now?: () => number;
+}
+/** Cancels a running `startScheduler` timer. */
+export type SchedulerHandle = () => void;
+/**
+ * Run one sweep: re-read every enabled `schedule` registration and deliver a
+ * tick for each one that is due. Exported separately from `startScheduler` so
+ * tests can drive it directly with a controlled `now`, without fighting a
+ * real or faked interval timer.
+ */
+export declare function runSchedulerSweepOnce(opts: {
+    wakeupService: TriggerWakeupService;
+    notify?: (event: SchedulerNotifyEvent) => void;
+    now?: () => number;
+}): Promise<void>;
+/**
+ * Start the scheduler's sweep timer. Follows `startReaper`'s shape
+ * (`@nodetool-ai/compute`): one unref'd `setInterval`, a swallowed per-sweep
+ * error so a transient DB hiccup doesn't kill the loop, and a stop handle.
+ */
+export declare function startScheduler(opts: StartSchedulerOptions): SchedulerHandle;
+export {};
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/triggers/scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../src/triggers/scheduler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAShE,yEAAyE;AACzE,UAAU,oBAAoB;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,qBAAqB;IAC7B,aAAa,EAAE,oBAAoB,CAAC;IACpC,yEAAyE;IACzE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAC/C,0EAA0E;IAC1E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wEAAwE;IACxE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED,gDAAgD;AAChD,MAAM,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC;AAoFzC;;;;;GAKG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE;IAChD,aAAa,EAAE,oBAAoB,CAAC;IACpC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAC/C,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC,IAAI,CAAC,CA0BhB;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,qBAAqB,GAAG,eAAe,CAkB3E"}

package/dist/triggers/scheduler.js

@@ -0,0 +1,122 @@
+/**
+ * Scheduler adapter — the host-owned ingestion adapter for `schedule`
+ * registrations (compiled from `IntervalTriggerNode`s, see
+ * `registration-sync.ts`).
+ *
+ * One coarse sweep timer (not one `setTimeout` per registration) re-reads
+ * enabled `schedule` registrations every tick and delivers a synthesized
+ * "tick" event for every one that is due, via `TriggerWakeupService`. This
+ * mirrors `@nodetool-ai/compute`'s `startReaper` shape: a single interval
+ * timer, an injectable clock, and a stop handle.
+ *
+ * Due-ness and the derived `input_id` are computed purely from persisted
+ * state (`created_at`, `last_fired_at`, `config_json`) and the current sweep
+ * time, so re-running the computation before `last_fired_at` is advanced —
+ * e.g. a process crash between delivering the input and persisting the new
+ * `last_fired_at` — reproduces the exact same `input_id` on the next sweep.
+ * `deliverTriggerInput`'s idempotency-by-`inputId` then makes that replay a
+ * no-op instead of a double-fire.
+ */
+import { createLogger } from "@nodetool-ai/config";
+import { TriggerRegistration } from "@nodetool-ai/models";
+import { computeScheduleTiming, SCHEDULE_KIND } from "./schedule-timing.js";
+import { isFunctionValue } from "../lib/wire-values.js";
+// Stryker disable next-line StringLiteral: logger name is a diagnostic label, not a behavioural contract
+const log = createLogger("nodetool.websocket.triggers.scheduler");
+const DEFAULT_SWEEP_INTERVAL_MS = 5_000;
+function synthesizeTickPayload(dueTickIndex, intervalSeconds, nowMs) {
+    return {
+        tick: dueTickIndex,
+        interval_seconds: intervalSeconds,
+        timestamp: new Date(nowMs).toISOString(),
+        source: "schedule",
+        event_type: "tick"
+    };
+}
+/**
+ * The due tick for a `schedule` registration, or `null` when the next due
+ * instant is still in the future. The instant itself comes from
+ * `computeScheduleTiming` (`schedule-timing.ts`), shared with the editor's
+ * "next fire" readout so the two cannot drift.
+ */
+function computeDueTick(registration, nowMs) {
+    const timing = computeScheduleTiming(registration);
+    if (!timing)
+        return null;
+    const { nextFireAtMs: dueAt, intervalMs, intervalSeconds } = timing;
+    if (nowMs < dueAt)
+        return null;
+    return {
+        dueAt,
+        dueTickIndex: Math.floor(dueAt / intervalMs),
+        intervalSeconds
+    };
+}
+async function fireRegistration(registration, due, wakeupService, nowMs, notify) {
+    const inputId = `${registration.id}:${due.dueTickIndex}`;
+    const payload = synthesizeTickPayload(due.dueTickIndex, due.intervalSeconds, nowMs);
+    try {
+        await wakeupService.deliverTriggerInput({
+            runId: registration.workflow_id,
+            nodeId: registration.node_id,
+            inputId,
+            payload
+        });
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        registration.last_error = error.message;
+        await registration.save();
+        log.warn(`Schedule registration ${registration.id} failed to deliver trigger input`, error);
+        return;
+    }
+    registration.last_fired_at = new Date(nowMs).toISOString();
+    registration.last_error = null;
+    await registration.save();
+    notify?.({ registrationId: registration.id, inputId });
+}
+/**
+ * Run one sweep: re-read every enabled `schedule` registration and deliver a
+ * tick for each one that is due. Exported separately from `startScheduler` so
+ * tests can drive it directly with a controlled `now`, without fighting a
+ * real or faked interval timer.
+ */
+export async function runSchedulerSweepOnce(opts) {
+    const nowMs = (opts.now ?? Date.now)();
+    const registrations = await TriggerRegistration.findEnabledByKind(SCHEDULE_KIND);
+    for (const registration of registrations) {
+        let due;
+        try {
+            due = computeDueTick(registration, nowMs);
+        }
+        catch (err) {
+            log.warn(`Failed to compute due tick for schedule registration ${registration.id}`, err instanceof Error ? err : new Error(String(err)));
+            continue;
+        }
+        if (!due)
+            continue;
+        await fireRegistration(registration, due, opts.wakeupService, nowMs, opts.notify);
+    }
+}
+/**
+ * Start the scheduler's sweep timer. Follows `startReaper`'s shape
+ * (`@nodetool-ai/compute`): one unref'd `setInterval`, a swallowed per-sweep
+ * error so a transient DB hiccup doesn't kill the loop, and a stop handle.
+ */
+export function startScheduler(opts) {
+    const intervalMs = opts.intervalMs ?? DEFAULT_SWEEP_INTERVAL_MS;
+    const timer = setInterval(() => {
+        void runSchedulerSweepOnce({
+            wakeupService: opts.wakeupService,
+            notify: opts.notify,
+            now: opts.now
+        }).catch((err) => {
+            log.warn("Scheduler sweep failed", err instanceof Error ? err : new Error(String(err)));
+        });
+    }, intervalMs);
+    if (isFunctionValue(timer.unref)) {
+        timer.unref();
+    }
+    return () => clearInterval(timer);
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/triggers/scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.js","sourceRoot":"","sources":["../../src/triggers/scheduler.ts"],"names":[],"mappings":"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"}

package/dist/triggers/settle.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Settle rules — what a dispatched run does to its registration.
+ *
+ * Split out of the dispatcher because these are decisions, not plumbing: a
+ * trigger that fails every time has to stop on its own (PRD O1), and a
+ * registration may carry an expiry or a run ceiling (F8). Both are pure
+ * functions over a registration row, so the tests read as a table rather than
+ * as a dispatch harness.
+ *
+ * `enabled` stays the one armed/disarmed bit. `disabled_reason` says who
+ * disarmed it: a non-null reason means the dispatcher gave up, `null` means a
+ * person switched it off. Re-arming clears the reason and the failure count —
+ * see `rearmTrigger`.
+ */
+import type { TriggerRegistration } from "@nodetool-ai/models";
+import { type TriggerDisabledReason } from "@nodetool-ai/protocol";
+/** Whether a registration may still start a run, and why not if it may not. */
+export type TriggerGate = {
+    allowed: true;
+} | {
+    allowed: false;
+    reason: TriggerDisabledReason;
+};
+/**
+ * Bounds checked *before* the run starts. An exhausted registration must not
+ * spend one more run proving it is exhausted.
+ */
+export declare function checkTriggerBounds(registration: TriggerRegistration, nowMs: number): TriggerGate;
+/** Disarm a registration, recording why. Does not save. */
+export declare function disableTrigger(registration: TriggerRegistration, reason: TriggerDisabledReason): void;
+/**
+ * Clear the dispatcher's verdict so a re-armed registration starts even.
+ * Without this a registration disabled after five failures would disable
+ * itself again on its next failure, one run in.
+ */
+export declare function rearmTrigger(registration: TriggerRegistration): void;
+interface TriggerOutcome {
+    /** The run's error, or `null` when it completed. */
+    error: string | null;
+    /** Whether this kind's fire time is the dispatcher's to stamp. */
+    stampFiredAt: boolean;
+    /** Fire time to stamp, ISO-8601. */
+    firedAt: string;
+}
+/**
+ * Apply a delivered run's outcome. Returns the reason the registration
+ * disarmed itself, or `null` if it stayed armed.
+ */
+export declare function settleTriggerOutcome(registration: TriggerRegistration, outcome: TriggerOutcome): TriggerDisabledReason | null;
+/**
+ * Params every triggered run receives (PRD F5), alongside the trigger event
+ * itself. They live here because `is_first_run` is defined by `run_count`,
+ * which only `settleTriggerOutcome` advances: a run that fails is not a first
+ * run spent, so a backfill-seeding graph sees `is_first_run` again on the
+ * retry.
+ *
+ * A workflow picks them up through Input nodes of the same name; one that
+ * declares none is unaffected.
+ */
+export declare function triggerRunParams(registration: TriggerRegistration, nowMs: number): {
+    last_fired_at: string | null;
+    now: string;
+    is_first_run: boolean;
+};
+export {};
+//# sourceMappingURL=settle.d.ts.map

package/dist/triggers/settle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settle.d.ts","sourceRoot":"","sources":["../../src/triggers/settle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,uBAAuB,CAAC;AAE/B,+EAA+E;AAC/E,MAAM,MAAM,WAAW,GACnB;IAAE,OAAO,EAAE,IAAI,CAAA;CAAE,GACjB;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,qBAAqB,CAAA;CAAE,CAAC;AAQtD;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,mBAAmB,EACjC,KAAK,EAAE,MAAM,GACZ,WAAW,CAgBb;AAED,2DAA2D;AAC3D,wBAAgB,cAAc,CAC5B,YAAY,EAAE,mBAAmB,EACjC,MAAM,EAAE,qBAAqB,GAC5B,IAAI,CAGN;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,YAAY,EAAE,mBAAmB,GAAG,IAAI,CAIpE;AAED,UAAU,cAAc;IACtB,oDAAoD;IACpD,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,kEAAkE;IAClE,YAAY,EAAE,OAAO,CAAC;IACtB,oCAAoC;IACpC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,mBAAmB,EACjC,OAAO,EAAE,cAAc,GACtB,qBAAqB,GAAG,IAAI,CAwB9B;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,mBAAmB,EACjC,KAAK,EAAE,MAAM;IAGX,aAAa;IACb,GAAG;IACH,YAAY;EAEf"}

package/dist/triggers/settle.js

@@ -0,0 +1,99 @@
+/**
+ * Settle rules — what a dispatched run does to its registration.
+ *
+ * Split out of the dispatcher because these are decisions, not plumbing: a
+ * trigger that fails every time has to stop on its own (PRD O1), and a
+ * registration may carry an expiry or a run ceiling (F8). Both are pure
+ * functions over a registration row, so the tests read as a table rather than
+ * as a dispatch harness.
+ *
+ * `enabled` stays the one armed/disarmed bit. `disabled_reason` says who
+ * disarmed it: a non-null reason means the dispatcher gave up, `null` means a
+ * person switched it off. Re-arming clears the reason and the failure count —
+ * see `rearmTrigger`.
+ */
+import { TRIGGER_MAX_CONSECUTIVE_FAILURES } from "@nodetool-ai/protocol";
+/** A `max_runs` of null or 0 means unlimited. */
+function spentItsRuns(registration) {
+    const maxRuns = registration.max_runs;
+    return maxRuns !== null && maxRuns > 0 && registration.run_count >= maxRuns;
+}
+/**
+ * Bounds checked *before* the run starts. An exhausted registration must not
+ * spend one more run proving it is exhausted.
+ */
+export function checkTriggerBounds(registration, nowMs) {
+    const expiresAt = registration.expires_at;
+    if (expiresAt) {
+        const expiryMs = Date.parse(expiresAt);
+        // An unparseable expiry is ignored rather than treated as expired:
+        // disabling on bad config would be a silent, unexplainable stop.
+        if (Number.isFinite(expiryMs) && nowMs >= expiryMs) {
+            return { allowed: false, reason: "expired" };
+        }
+    }
+    if (spentItsRuns(registration)) {
+        return { allowed: false, reason: "max_runs" };
+    }
+    return { allowed: true };
+}
+/** Disarm a registration, recording why. Does not save. */
+export function disableTrigger(registration, reason) {
+    registration.enabled = 0;
+    registration.disabled_reason = reason;
+}
+/**
+ * Clear the dispatcher's verdict so a re-armed registration starts even.
+ * Without this a registration disabled after five failures would disable
+ * itself again on its next failure, one run in.
+ */
+export function rearmTrigger(registration) {
+    registration.enabled = 1;
+    registration.disabled_reason = null;
+    registration.consecutive_failures = 0;
+}
+/**
+ * Apply a delivered run's outcome. Returns the reason the registration
+ * disarmed itself, or `null` if it stayed armed.
+ */
+export function settleTriggerOutcome(registration, outcome) {
+    if (outcome.stampFiredAt) {
+        registration.last_fired_at = outcome.firedAt;
+    }
+    registration.last_error = outcome.error;
+    if (outcome.error === null) {
+        registration.consecutive_failures = 0;
+        registration.run_count += 1;
+        // Also checked before dispatch, but disarming here means the UI says so
+        // straight away instead of waiting for an event that may never arrive.
+        if (spentItsRuns(registration)) {
+            disableTrigger(registration, "max_runs");
+            return "max_runs";
+        }
+        return null;
+    }
+    registration.consecutive_failures += 1;
+    if (registration.consecutive_failures >= TRIGGER_MAX_CONSECUTIVE_FAILURES) {
+        disableTrigger(registration, "failures");
+        return "failures";
+    }
+    return null;
+}
+/**
+ * Params every triggered run receives (PRD F5), alongside the trigger event
+ * itself. They live here because `is_first_run` is defined by `run_count`,
+ * which only `settleTriggerOutcome` advances: a run that fails is not a first
+ * run spent, so a backfill-seeding graph sees `is_first_run` again on the
+ * retry.
+ *
+ * A workflow picks them up through Input nodes of the same name; one that
+ * declares none is unaffected.
+ */
+export function triggerRunParams(registration, nowMs) {
+    return {
+        last_fired_at: registration.last_fired_at,
+        now: new Date(nowMs).toISOString(),
+        is_first_run: registration.run_count === 0
+    };
+}
+//# sourceMappingURL=settle.js.map

package/dist/triggers/settle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settle.js","sourceRoot":"","sources":["../../src/triggers/settle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EACL,gCAAgC,EAEjC,MAAM,uBAAuB,CAAC;AAO/B,iDAAiD;AACjD,SAAS,YAAY,CAAC,YAAiC;IACrD,MAAM,OAAO,GAAG,YAAY,CAAC,QAAQ,CAAC;IACtC,OAAO,OAAO,KAAK,IAAI,IAAI,OAAO,GAAG,CAAC,IAAI,YAAY,CAAC,SAAS,IAAI,OAAO,CAAC;AAC9E,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAChC,YAAiC,EACjC,KAAa;IAEb,MAAM,SAAS,GAAG,YAAY,CAAC,UAAU,CAAC;IAC1C,IAAI,SAAS,EAAE,CAAC;QACd,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QACvC,mEAAmE;QACnE,iEAAiE;QACjE,IAAI,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,KAAK,IAAI,QAAQ,EAAE,CAAC;YACnD,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;QAC/C,CAAC;IACH,CAAC;IAED,IAAI,YAAY,CAAC,YAAY,CAAC,EAAE,CAAC;QAC/B,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;IAChD,CAAC;IAED,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;AAC3B,CAAC;AAED,2DAA2D;AAC3D,MAAM,UAAU,cAAc,CAC5B,YAAiC,EACjC,MAA6B;IAE7B,YAAY,CAAC,OAAO,GAAG,CAAC,CAAC;IACzB,YAAY,CAAC,eAAe,GAAG,MAAM,CAAC;AACxC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,YAAiC;IAC5D,YAAY,CAAC,OAAO,GAAG,CAAC,CAAC;IACzB,YAAY,CAAC,eAAe,GAAG,IAAI,CAAC;IACpC,YAAY,CAAC,oBAAoB,GAAG,CAAC,CAAC;AACxC,CAAC;AAWD;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAClC,YAAiC,EACjC,OAAuB;IAEvB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;QACzB,YAAY,CAAC,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC;IAC/C,CAAC;IACD,YAAY,CAAC,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC;IAExC,IAAI,OAAO,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;QAC3B,YAAY,CAAC,oBAAoB,GAAG,CAAC,CAAC;QACtC,YAAY,CAAC,SAAS,IAAI,CAAC,CAAC;QAC5B,wEAAwE;QACxE,uEAAuE;QACvE,IAAI,YAAY,CAAC,YAAY,CAAC,EAAE,CAAC;YAC/B,cAAc,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;YACzC,OAAO,UAAU,CAAC;QACpB,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,YAAY,CAAC,oBAAoB,IAAI,CAAC,CAAC;IACvC,IAAI,YAAY,CAAC,oBAAoB,IAAI,gCAAgC,EAAE,CAAC;QAC1E,cAAc,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;QACzC,OAAO,UAAU,CAAC;IACpB,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAC9B,YAAiC,EACjC,KAAa;IAEb,OAAO;QACL,aAAa,EAAE,YAAY,CAAC,aAAa;QACzC,GAAG,EAAE,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE;QAClC,YAAY,EAAE,YAAY,CAAC,SAAS,KAAK,CAAC;KAC3C,CAAC;AACJ,CAAC"}

package/dist/triggers/stores.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Database-backed implementations of the kernel's trigger storage interfaces.
+ *
+ * The kernel defines `TriggerInputStore` and `DurableInboxStore` but stays
+ * store-agnostic — it cannot depend on `@nodetool-ai/models` without inverting
+ * the package order. These adapters live in the server package, which already
+ * owns the database.
+ *
+ * Queries use Drizzle's relational callback API (`db.query.<table>`) so this
+ * package needs no direct `drizzle-orm` dependency and works on both the
+ * SQLite and PostgreSQL dialects.
+ */
+import type { DurableInboxStore, DurableMessage, TriggerInput as TriggerInputRecord, TriggerInputStore } from "@nodetool-ai/kernel";
+/**
+ * `TriggerInputStore` over the `trigger_inputs` table.
+ */
+export declare class DrizzleTriggerInputStore implements TriggerInputStore {
+    has(inputId: string): Promise<boolean>;
+    insertIfAbsent(input: TriggerInputRecord): Promise<boolean>;
+    findUnprocessed(runId: string, nodeId: string, limit?: number): Promise<TriggerInputRecord[]>;
+    markProcessed(inputId: string): Promise<void>;
+    cleanupProcessed(runId: string, nodeId: string, olderThanHours?: number): Promise<number>;
+    hasInputsFor(runId: string, nodeId: string): Promise<boolean>;
+    deleteRun(runId: string): Promise<void>;
+}
+/**
+ * `DurableInboxStore` over the `run_inbox_messages` table.
+ */
+export declare class DrizzleDurableInboxStore implements DurableInboxStore {
+    private row;
+    findByMessageId(messageId: string): Promise<DurableMessage | null>;
+    save(message: DurableMessage): Promise<void>;
+    findPending(runId: string, nodeId: string, handle: string, limit: number, minSeq?: number): Promise<DurableMessage[]>;
+    getMaxSeq(runId: string, nodeId: string, handle: string): Promise<number>;
+    markConsumed(messageId: string): Promise<void>;
+    deleteConsumed(runId: string, nodeId: string, handle: string, olderThanSeq: number): Promise<number>;
+}
+//# sourceMappingURL=stores.d.ts.map

package/dist/triggers/stores.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stores.d.ts","sourceRoot":"","sources":["../../src/triggers/stores.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EACV,iBAAiB,EACjB,cAAc,EACd,YAAY,IAAI,kBAAkB,EAClC,iBAAiB,EAClB,MAAM,qBAAqB,CAAC;AA4D7B;;GAEG;AACH,qBAAa,wBAAyB,YAAW,iBAAiB;IAC1D,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAE3C;IAEK,cAAc,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC,CAoBhE;IAEK,eAAe,CACnB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,KAAK,SAAM,GACV,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAQ/B;IAEK,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAElD;IAEK,gBAAgB,CACpB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,cAAc,SAAK,GAClB,OAAO,CAAC,MAAM,CAAC,CAkBjB;IAEK,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAKlE;IAEK,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAO5C;CACF;AAED;;GAEG;AACH,qBAAa,wBAAyB,YAAW,iBAAiB;YAClD,GAAG;IAOX,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAGvE;IAEK,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAajD;IAEK,WAAW,CACf,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,SAAI,GACT,OAAO,CAAC,cAAc,EAAE,CAAC,CAc3B;IAEK,SAAS,CACb,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,CAAC,CAEjB;IAEK,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAMnD;IAEK,cAAc,CAClB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,CAAC,CAejB;CACF"}