eve 0.66.2 → 0.66.3

package/dist/src/compiled/@workflow/core/runtime/hook-wake.d.ts

@@ -0,0 +1,89 @@
+import { type Event, type Hook, type World } from '#compiled/@workflow/world/index.js';
+/**
+ * A wake failure worth retrying is transport-shaped (network error, 5xx,
+ * throttle). A definitive rejection will not change on a 25ms retry, so
+ * spending the budget on it only delays the caller's error.
+ *
+ * `@vercel/queue` errors carry no `status` field — they are bare `Error`
+ * subclasses distinguished by `name` — so classification checks the World's
+ * deployment-unavailable hook first (a deployment the queue cannot discover
+ * will not come back within this function's ~125ms budget), then a numeric
+ * status when one exists (non-Vercel queue implementations), then the queue
+ * client's definitive-4xx error names.
+ */
+export declare function isRetryableWakeError(error: unknown, isDeploymentUnavailableError?: (error: unknown) => boolean): boolean;
+/**
+ * Publish a workflow wake, retrying transport-shaped failures.
+ *
+ * A publish may succeed even when its response is lost, so a retry can
+ * enqueue a duplicate wake. That is harmless: the event the wake exists to
+ * deliver is already durable, and deterministic replay makes a second
+ * delivery of the same run a no-op.
+ */
+export declare function publishHookWakeWithRetry(publish: () => Promise<unknown>, isDeploymentUnavailableError?: (error: unknown) => boolean): Promise<void>;
+/**
+ * Wake the run a force-claimed hook took its token from.
+ *
+ * The takeover left a `hook_disposed{forceClaimedBy}` in that run's log, and
+ * a run suspended on `await hook` reads it only when something invokes it.
+ * The World cannot publish that wake (it has no queue), so the claimer's
+ * runtime does, right after its `hook_created` returns, from the victim's
+ * `workflowName` / `deploymentId` the World recorded on `hook.claimedFrom`.
+ *
+ * Same durability contract as `resumeHook()`'s wake: the row is durable
+ * before this runs, the publish is retried on transport-shaped failures, and
+ * a publish that still fails is logged rather than failing the claimer —
+ * nothing of the claimer's is wrong, and the victim reads the row on its
+ * next invocation for any reason. The idempotency key is the claimer's hook
+ * id, so a claimer retrying its creation republishes at most one wake.
+ *
+ * Skipped when the victim is the claimer itself (a run taking over its own
+ * earlier hook is already running) and when the World recorded no
+ * `workflowName` for the victim (a legacy hook; nothing to address a queue
+ * message to).
+ */
+export declare function publishForceClaimVictimWake(world: World, claimerRunId: string, hook: Pick<Hook, 'hookId' | 'claimedFrom'>): Promise<'published' | 'skipped' | 'failed'>;
+/**
+ * The forced hook creation whose victim wake this run still owes, if any: the
+ * forced `hook_created` is the last event the run's own replay appended.
+ *
+ * A forced creation is followed by a wake of the run it took the token from.
+ * If the invocation died between the two, the creation is in the log and the
+ * victim was never told; the row itself is the durable record of that debt.
+ * As long as it is the last event THIS RUN wrote, the run has made no progress
+ * since, so the invocation that should have woken the victim did not finish,
+ * and the replay republishes (under the hook's idempotency key, so a wake that
+ * did go out is not duplicated). The first event the run appends after it
+ * ends the republishing.
+ *
+ * "This run wrote" matters: a delivery appends `hook_received` to this log
+ * from another request, a sealed-log World appends `noop`, and a LATER
+ * claimer taking the token from this run appends
+ * `hook_disposed{forceClaimedBy}`. None is progress of this run — the model
+ * (`ForceWakeOnce.cfg`'s sibling trace) has a delivery land between the crash
+ * and the retry, and a rule that looked at the bare tail would then never
+ * wake the victim. The foreign disposal is the chain case: this run took the
+ * token from A, died before waking A, and was itself taken from by C. Its own
+ * wake (from C) is the very invocation that must repay A's — the run's own
+ * `hook_disposed` (a `dispose()` in its code) IS its progress and still ends
+ * the debt, but a row another run put here does not. Both engines call this
+ * on the log they loaded for the invocation, before writing anything.
+ *
+ * Reading only the last own row is sound because both engines keep every
+ * other write of the invocation off that tail until the wake is out: a token
+ * group holding a forced creation runs first, one group at a time, publishing
+ * its wake before its next write, and nothing else is dispatched until those
+ * groups have settled. Were a sibling hook's creation (or, in QuickJS, a step
+ * or wait) allowed to land concurrently, a crash before the publish would
+ * leave that row last and hide the debt.
+ */
+export declare function forcedCreationOwingWake(events: readonly Event[] | undefined): (Event & {
+    eventType: 'hook_created';
+}) | undefined;
+/**
+ * Republish the wake {@link forcedCreationOwingWake} says is owed. Shared by
+ * the node:vm suspension handler and the QuickJS entrypoint so the two engines
+ * cannot drift on the durability contract.
+ */
+export declare function republishOwedForceClaimVictimWake(world: World, runId: string, events: readonly Event[] | undefined): Promise<void>;
+//# sourceMappingURL=hook-wake.d.ts.map

package/dist/src/compiled/@workflow/core/runtime/open-hook-wait-state.d.ts

@@ -0,0 +1,55 @@
+import type { Event } from '#compiled/@workflow/world/index.js';
+/**
+ * Which out-of-band writers a replay's event log currently admits, computed
+ * purely from the log.
+ */
+export interface OpenHookAndWaitState {
+    /** A `hook_created` with no `hook_disposed`: a webhook receiver can append `hook_received`. */
+    openHook: boolean;
+    /** A `wait_created` with no `wait_completed`: the wait timer can append `wait_completed`. */
+    openWait: boolean;
+    /**
+     * The earliest `resumeAt` among the open waits, as epoch milliseconds.
+     * `undefined` when there is no open wait. `-Infinity` when at least one
+     * open wait carries no parseable `resumeAt`: a wait whose deadline cannot
+     * be read is treated as due now, so it gates exactly as an open wait did
+     * before deadlines were consulted.
+     */
+    earliestOpenWaitResumeAtMs: number | undefined;
+}
+/**
+ * Whether the run has a hook and/or wait that an out-of-band writer could
+ * append an event for between an inline step's `step_completed` write and
+ * the next replay, namely an open hook (a `hook_created` not yet
+ * `hook_disposed`, which a webhook receiver can resolve with
+ * `hook_received`) or an open wait (a `wait_created` not yet
+ * `wait_completed`, which the wait timer can resolve with
+ * `wait_completed`).
+ *
+ * Open waits that can fire during this invocation (see
+ * {@link hasOpenWaitDueBy}) block inline deltas. Open hooks and such waits
+ * disable turbo's forced optimistic start. Open hooks additionally suppress operator-enabled optimistic start
+ * until the `step_started` claim succeeds; open waits leave that explicit,
+ * idempotency-only opt-in alone.
+ *
+ * A wait that lost a `Promise.race` against a hook stays open until its timer
+ * elapses (there is no event that disposes a wait), which is why the
+ * deadline matters: without it a `sleep('24h')` timeout branch would hold
+ * every later step boundary of the run on the slow path.
+ *
+ * Step-body `attr_set` writes are NOT a concern: they land before the
+ * step's terminal write and are therefore already inside the returned
+ * delta.
+ */
+export declare function openHookAndWaitState(events: Event[]): OpenHookAndWaitState;
+/**
+ * Whether an open wait is due at or before `deadlineMs` (epoch ms), so its
+ * `wait_completed`, or the resume invocation carrying it, could arrive while
+ * the caller is still exposed. A wait whose deadline is already past, or
+ * cannot be read, is due. A log with no open wait is not.
+ *
+ * The runtime passes the end of the invocation's inline window plus a skew
+ * allowance; the reasoning is on `OPEN_WAIT_CLOCK_SKEW_MS`.
+ */
+export declare function hasOpenWaitDueBy(state: Pick<OpenHookAndWaitState, 'earliestOpenWaitResumeAtMs'>, deadlineMs: number): boolean;
+//# sourceMappingURL=open-hook-wait-state.d.ts.map

package/dist/src/compiled/@workflow/core/runtime/quickjs-runtime.d.ts

@@ -72,6 +72,8 @@ export interface PendingHook {
     /** Earliest token reuse time, as milliseconds since the Unix epoch. */
     tokenRetentionUntil?: number;
     isWebhook: boolean;
+    /** `createHook({ experimental_force })`: take the token over if held. */
+    force?: boolean;
     metadata?: unknown;
     hasCreatedEvent: boolean;
     /**

package/dist/src/compiled/@workflow/core/runtime/suspension-handler.d.ts

@@ -185,11 +185,18 @@ export interface SuspensionHandlerResult {
      * correlationId of the wait that produced that timeout. The
      * correlationId seeds the idempotency key for the wait-continuation
      * queue message so that repeated suspension passes over the same
-     * pending wait collapse into a single delayed continuation.
+     * pending wait collapse into a single delayed continuation. `resumeAtMs`
+     * is that wait's absolute deadline, for gates that ask whether it can fire
+     * within some window rather than how long until it does.
+     *
+     * Covers every wait still in the workflow's queue, not only ones this
+     * suspension created: a `sleep()` that lost a `Promise.race` stays queued
+     * (and reported here) until its `wait_completed` lands.
      */
     waitTimeout?: {
         seconds: number;
         correlationId: string;
+        resumeAtMs: number;
     };
     /**
      * Whether a hook create committed a `hook_conflict` — the token was already