@voltro/runtime 0.24.0 → 0.26.0

package/dist/index.d.ts

@@ -14,8 +14,16 @@ import { DialectId } from '@voltro/database';
 import { DialectReplicationAdapter } from '@voltro/database';
 import { Duration } from 'effect';
 import { Effect } from 'effect';
+import { EventDeliverySemantics } from '@voltro/protocol';
+import { EventDescriptor } from '@voltro/protocol';
+import { EventKeyInvalid } from '@voltro/protocol';
+import { EventPayloadInvalid } from '@voltro/protocol';
+import { EventPayloadTooLarge } from '@voltro/protocol';
+import { EventResumePoint } from '@voltro/protocol';
+import { EventStreamEvent } from '@voltro/protocol';
 import { Fiber } from 'effect';
 import { FieldCipher } from '@voltro/database';
+import { Guards } from '@voltro/protocol';
 import * as http from 'node:http';
 import { HttpClient } from '@effect/platform';
 import { HttpRequestInterceptor } from '@voltro/protocol';
@@ -35,6 +43,7 @@ import { Metric } from 'effect';
 import { MetricBoundaries } from 'effect';
 import { MetricReader } from '@opentelemetry/sdk-metrics';
 import { PluginHttpRoute } from '@voltro/protocol';
+import { PluginRefOrphanPolicy } from '@voltro/database';
 import { Predicate } from '@voltro/database';
 import { Query } from '@voltro/database';
 import { QueryDescriptor } from '@voltro/database';
@@ -855,7 +864,7 @@ export declare interface AppContext {
      *  recompute. */
     readonly kv: AsyncKv;
     /** Webhooks service — present when `@voltro/plugin-webhooks` is in
-     *  the app's plugin list. Use `defineOutgoingEvent(...)` in a
+     *  the app's plugin list. Declare the event with `defineEvent({ …, webhook })` in a
      *  `*.webhook.tsx` file to declare an event, then `ctx.webhooks.emit(
      *  'eventId', payload)` from any handler. */
     readonly webhooks?: WebhooksAppContext;
@@ -863,10 +872,23 @@ export declare interface AppContext {
      *  `*.workflow.tsx` files. Starts return a run handle immediately;
      *  `wait`/`poll`/`signal`/`cancel` are explicit operations. */
     readonly workflows?: WorkflowsAppContext;
-    /** Domain event service — present when the app has workflow event
-     *  triggers. `emit(name, payload)` records the event and fans out to
-     *  matching workflow triggers. */
-    readonly events?: EventsAppContext;
+    /**
+     * `ctx.events.publish(descriptor, key, payload)` — present when the app
+     * declares `*.event.ts` files.
+     *
+     * This was typed as the OLD string-emitter facade (`emit(name, data)`) long
+     * after that facade was deleted, so the documented call was a `tsc` error
+     * while the runtime carried only `publish` — a consumer measured
+     * `eventKeys: ["publish"], emitType: undefined` with a cron probe because the
+     * type and the docs disagreed and they could not tell which was lying.
+     *
+     * What let it drift is worth naming: the builder installed the publisher with
+     * `as never`, so the compiler had the answer the whole time and was told not
+     * to give it. `appContext.ts` even carried a comment stating `emit` is gone —
+     * beside the cast that hid it. A context field is the one place this repo
+     * treats such a cast as a defect in its own right.
+     */
+    readonly events?: EventPublisher;
     /**
      * Transactional outbox (`ctx.outbox`). Absent when the app declares no
      * `*.outbox.ts` handler — an enqueue with nobody to deliver it would be a
@@ -928,6 +950,18 @@ export declare const applyInverse: (store: UndoApplyStore, op: InverseOp) => Pro
  *  `synthesizeInverse`), as the caller's transaction wraps them. */
 export declare const applyInverses: (store: UndoApplyStore, ops: ReadonlyArray<InverseOp>) => Promise<void>;
 
+/**
+ * Apply every rule matching `change`.
+ *
+ * Returns what it did, so a caller can log it. Never throws for a rule that
+ * finds nothing — an orphan rule firing on a row nobody references is the
+ * normal case, not an error.
+ */
+export declare const applyPluginRefRules: (store: PluginRefStore, rules: ReadonlyArray<PluginRefRule>, change: PluginRefChange) => Promise<ReadonlyArray<{
+    readonly rule: PluginRefRule;
+    readonly affected: number;
+}>>;
+
 /** AND-merge the row filter for `table` onto an existing predicate. */
 export declare const applyRowFilter: (scope: RowFilterScope, table: string, predicate: Predicate | undefined) => Predicate | undefined;
 
@@ -1069,6 +1103,17 @@ export declare interface AuditableQuery {
     readonly source?: string | ReadonlyArray<string> | undefined;
 }
 
+/**
+ * An Effect that is ALSO awaitable.
+ *
+ * The intersection is the type-level half of the fix: without `PromiseLike`,
+ * `await ctx.events.publish(…)` type-checks (awaiting a non-Promise is legal)
+ * and hands back the EFFECT rather than the result — so even after the runtime
+ * behaviour was fixed, the value an async handler got would have been typed
+ * wrong. Both halves are needed, and both are pinned by tests.
+ */
+export declare type AwaitableEffect<A, E> = Effect.Effect<A, E> & PromiseLike<A>;
+
 /**
  * Resolve once a server returned by {@link startRpcServer} has actually
  * bound its port (node `'listening'` event). REJECTS on `'error'`
@@ -1117,6 +1162,37 @@ export declare interface BeginOAuthResult {
  */
 export declare const bindConnectionSubject: (clientId: number, subject: Subject) => void;
 
+/**
+ * Bind one client's subscription to a declared event.
+ *
+ * The TENANT comes from the resolved subject and from nowhere else, so a
+ * cross-tenant subscription is not something a caller can ask for. `key` has
+ * already been decoded by the rpc layer against the descriptor's schema.
+ *
+ * The stream ends when the client disconnects, through the same per-connection
+ * interrupt registry subscriptions use — so one reconnect policy, one devtools
+ * view, one connection lifecycle for both primitives.
+ */
+export declare const bindEvent: (input: BindEventInput) => Stream.Stream<EventStreamEvent<unknown>, ScopeError, SubjectService | ConnectionInfo>;
+
+export declare interface BindEventInput {
+    readonly bus: EventBus;
+    readonly event: string;
+    /** Decoded routing key, exactly as the descriptor declares it. */
+    readonly key: unknown;
+    readonly options?: EventSubscribeOptions | undefined;
+    /** Queue depth override — tests use a tiny one to force the drop path. */
+    readonly queueSize?: number;
+    /**
+     * The descriptor's `guards:` — WHO MAY LISTEN.
+     *
+     * Passed in rather than read from a registry so there is exactly one way for a
+     * subscription to be authorised, and it is the same list the manifest, the
+     * doctor and the dashboard report on.
+     */
+    readonly guards?: Guards<unknown> | undefined;
+}
+
 export declare const bindMutation: <Input, Output, E = never>(execute: (input: Input, context: RuntimeContext) => Output | Promise<Output> | Effect.Effect<Output, E, never>, input: Input, spanName?: string, codec?: MutationOutputCodec<unknown>, idempotency?: IdempotencyBinding) => Effect.Effect<Output, E, SubjectService | ConnectionInfo>;
 
 /**
@@ -1128,7 +1204,25 @@ export declare const bindMutation: <Input, Output, E = never>(execute: (input: I
  * finalizers run → the provider request aborts), reusing the same
  * per-connection interrupt registry subscriptions use.
  */
-export declare const bindStream: <Element, Err = unknown>(buildStream: (context: RuntimeContext) => Stream.Stream<Element, Err, never> | Effect.Effect<Stream.Stream<Element, Err, never>, unknown, never>, spanName?: string) => Stream.Stream<Element, Err, SubjectService | ConnectionInfo>;
+export declare const bindStream: <Element, Err = unknown>(buildStream: (context: RuntimeContext) => Stream.Stream<Element, Err, never> | Effect.Effect<Stream.Stream<Element, Err, never>, unknown, never>, spanName?: string, 
+/**
+ * The stream's declared `guards:`, when it has any.
+ *
+ * Checked once at subscribe AND before every element, exactly as a query's
+ * are. A stream was the one realtime primitive that could not express
+ * authorization at all, so whatever protection existed was hand-written in an
+ * executor where nothing could verify it was there.
+ *
+ * A denial ENDS the stream rather than dropping the element: a skipped
+ * element is indistinguishable from "nothing to send", and the client must
+ * learn it lost access instead of inferring it from silence.
+ */
+guards?: ReadonlyArray<unknown> | undefined, 
+/** The call's decoded input — the guard INPUT, so a resource-scoped guard
+ *  (`{ scope: 'x:read', from: 'id' }`) can see which resource was asked for.
+ *  Passed explicitly rather than read off RuntimeContext, which does not
+ *  carry it. */
+guardInput?: unknown) => Stream.Stream<Element, Err, SubjectService | ConnectionInfo>;
 
 /**
  * Build a `Stream<SubscriptionEvent<T>>` that an @effect/rpc streaming
@@ -1323,6 +1417,7 @@ export declare interface CandidateShape {
     readonly windowed?: boolean;
 }
 
+/* Excluded from this release type: canonicalize */
 export { CaughtUpVerdict }
 
 /** A CDC change event, structurally — what the reactive engine already emits
@@ -1422,6 +1517,28 @@ export { clearRetentions }
 /** Clear the process-wide handle (test teardown). */
 export declare const clearSystemStoreHandle: () => void;
 
+/**
+ * Collect the declared rules from the discovered tables.
+ *
+ * `tables` is the boot's table set. Each column carrying a `pluginRef` spec
+ * contributes one rule, with the target resolved through the plugin's exported
+ * handle — so a rename carries the rule.
+ *
+ * Throws when a `pluginRef` names a table nothing registered: a declared rule
+ * against an absent plugin would sit there looking enforced and never fire,
+ * which is the exact failure this framework has shipped too often. The message
+ * names both sides so the fix is obvious (install the plugin, or drop the
+ * column).
+ */
+export declare const collectPluginRefRules: (tables: ReadonlyArray<{
+    readonly name: string;
+    readonly columns: Record<string, unknown>;
+}>, specOf: (column: unknown) => {
+    target: () => unknown;
+    orphanPolicy: PluginRefOrphanPolicy;
+    onSoftDelete: boolean;
+} | undefined, registered: ReadonlySet<string>) => ReadonlyArray<PluginRefRule>;
+
 /** Parse + return the compiled `Cron` for a definition. Throws the
  *  same way `defineSchedule` validated — callers that already hold a
  *  branded definition can trust this won't throw. */
@@ -1929,7 +2046,13 @@ export declare const defineAggregate: <Row>(input: AggregateDefinitionInput<Row>
  */
 export declare const defineConnection: <D extends ConnectionDefinition>(definition: D) => D;
 
-export declare const defineEventTrigger: <EventPayload = unknown, WorkflowPayload = EventPayload>(spec: Omit<WorkflowEventTriggerDefinition<EventPayload, WorkflowPayload>, "_tag">) => WorkflowEventTriggerDefinition<EventPayload, WorkflowPayload>;
+export declare const defineEventTrigger: <EventPayload = unknown, WorkflowPayload = EventPayload>(spec: Omit<WorkflowEventTriggerDefinition<EventPayload, WorkflowPayload>, "_tag"> | (Omit<WorkflowEventTriggerDefinition<EventPayload, WorkflowPayload>, "_tag" | "event"> & {
+    /** A declared event. Its `name` becomes the matched event. */
+    readonly on: {
+        readonly kind: "event";
+        readonly name: string;
+    };
+})) => WorkflowEventTriggerDefinition<EventPayload, WorkflowPayload>;
 
 /**
  * Type a procedure executor against its descriptor's `output` (and `input`).
@@ -2116,6 +2239,27 @@ export declare class Dispatcher {
     onSubscriptionsChange(listener: () => void): () => void;
     /** Tear down the change-event listener. Call on server shutdown. */
     close(): void;
+    /**
+     * Re-run EVERY live subscription, because this replica proved it missed
+     * changes it can never recover.
+     *
+     * The broadcast bus detects a serial gap from a peer; pub/sub keeps no log,
+     * so the lost ChangeEvents are gone. That does not matter, and the reason it
+     * does not matter is the whole design: a live query is IDEMPOTENT. Re-running
+     * one is always safe and always lands on the truth, so a proven loss is
+     * repaired by refreshing rather than by replaying.
+     *
+     * Without this a dropped message leaves a client stale FOREVER — its socket
+     * never breaks, so the client-side reconnect never fires, and its query does
+     * not re-run until something else happens to touch the same table. On a quiet
+     * table that is never, and the only symptom is a user saying the page did not
+     * update.
+     *
+     * Deliberately blunt. It re-queries every subscription rather than reasoning
+     * about which tables the lost changes touched — we do not know, and guessing
+     * narrower would reintroduce exactly the silent staleness this repairs.
+     */
+    refreshAll(reason: string): Promise<void>;
     private handleChange;
 }
 
@@ -2261,6 +2405,320 @@ export declare const enterRequestLoader: (loader: DataLoader) => void;
  *  Promise-wrapped to satisfy the async contract. */
 export declare const envSecretsBackend: SecretsBackend;
 
+/**
+ * How many deliveries one client may fall behind before the oldest are dropped.
+ *
+ * Sized to match the bus's ring: a client that falls further behind than the
+ * server retains could not be made whole on reconnect anyway, so a deeper queue
+ * would only delay the same honest answer.
+ */
+export declare const EVENT_CLIENT_QUEUE_SIZE = 64;
+
+/**
+ * The queue depth for a `latest` event: exactly one.
+ *
+ * Not a smaller buffer — a DIFFERENT contract. A depth of one on a sliding queue
+ * means a delivery arriving while another is pending REPLACES it, which is what
+ * "only the current value matters" means when the consumer is slow. Anything
+ * deeper would hand a 60Hz display a backlog to work through before it could
+ * reach the state it actually wanted to show.
+ */
+export declare const EVENT_LATEST_QUEUE_SIZE = 1;
+
+export declare class EventBus {
+    private readonly routes;
+    private readonly origin;
+    private readonly ringSize;
+    private readonly ringTtlMs;
+    private readonly maxRoutes;
+    private readonly publishRemote;
+    private readonly deliveryOf;
+    /** Live local subscriber count per EVENT — the basis of channel interest. */
+    private readonly interest;
+    private readonly interestListeners;
+    private readonly now;
+    constructor(options: EventBusOptions);
+    /** This instance's id — the `origin` on everything it publishes. */
+    get instanceOrigin(): string;
+    /**
+     * Be told when this instance gains its FIRST or loses its LAST local
+     * subscriber for an event.
+     *
+     * The transport uses it to hold a cross-instance subscription only while
+     * somebody here is listening. Without it every replica receives, decodes and
+     * materialises a route for every event of every peer — including the ones it
+     * serves no clients for, which for a high-rate event is the bulk of the work
+     * it does and none of the work it needs.
+     *
+     * Registering REPLAYS the currently-active events synchronously, because the
+     * transport is attached after the bus exists: a subscriber that arrived in
+     * between would otherwise be invisible until it left and came back.
+     */
+    onInterestChange(listener: (event: string, active: boolean) => void): () => void;
+    private shiftInterest;
+    private notifyInterest;
+    /** Events this instance currently has at least one local subscriber for. */
+    activeEvents(): ReadonlyArray<string>;
+    /**
+     * One event's declared delivery semantics — what the bridge sizes its queue
+     * from, so the two cannot disagree about whether a drop is a loss.
+     */
+    deliveryFor(event: string): EventDeliverySemantics;
+    private state;
+    /**
+     * Drop the coldest IDLE routes when over the ceiling.
+     *
+     * A route with live listeners is never evicted regardless of age: evicting it
+     * would silently stop delivering to a connected subscriber, which is the exact
+     * class of failure this bus exists to make impossible. Only retention is
+     * sacrificed under pressure, never delivery.
+     */
+    private evictIfOverCapacity;
+    /**
+     * Drop what the ring may no longer replay.
+     *
+     * IN PLACE. The obvious version — `ring = ring.slice(drop)` — allocates and
+     * copies the whole ring on EVERY publish once it is full, which measured as
+     * the single largest cost in the publish path (5.8µs with a full ring against
+     * 0.35µs for everything else combined: the key encoding, the route, and the
+     * size gate's JSON put together). `splice` mutates, so a saturated route costs
+     * the same as an empty one.
+     *
+     * Worth keeping in mind if this is ever rewritten as a true circular buffer:
+     * the win here was removing the ALLOCATION, not the copy. A 64-element
+     * `splice(0, 1)` is cheap; a 64-element fresh array every 5 microseconds is
+     * what the garbage collector notices.
+     */
+    private pruneRing;
+    /**
+     * Publish an already-validated, already-size-checked envelope body.
+     *
+     * Validation lives at the `ctx.events.publish` seam rather than here because
+     * that is where the descriptor is — the bus deals in routes and bytes.
+     */
+    publish(input: {
+        readonly tenantId: string | null;
+        readonly event: string;
+        readonly key: unknown;
+        readonly payload: unknown;
+    }): EventEnvelope;
+    /**
+     * Take a delivery published by ANOTHER instance.
+     *
+     * Ignores our own origin echoed back: the local subscribers were already
+     * served synchronously at publish time, so accepting it here would deliver
+     * twice and break the serial contract (`n` would repeat).
+     */
+    injectRemote(envelope: EventEnvelope): void;
+    private accept;
+    /**
+     * Subscribe to one route. Returns the unsubscribe.
+     *
+     * The listener is invoked synchronously from `publish`, in registration order.
+     * Anything the subscriber needs to do slowly belongs behind its own queue —
+     * see the bridge.
+     */
+    subscribe(input: {
+        readonly tenantId: string | null;
+        readonly event: string;
+        readonly key: unknown;
+        readonly listener: EventListener_2;
+        readonly options?: EventSubscribeOptions | undefined;
+        /**
+         * Called SYNCHRONOUSLY at attach with the route's current watermarks.
+         *
+         * It is how a consumer learns where the stream stood the instant it joined,
+         * with no window for a publish to slip in between reading and subscribing.
+         * The bridge needs it because a delivery dropped BEFORE the client's first
+         * read would otherwise be invisible: with no baseline, the first serial it
+         * sees looks like a starting point rather than evidence of what came before.
+         */
+        readonly onAttach?: ((watermark: ReadonlyMap<string, number>) => void) | undefined;
+    }): () => void;
+    /**
+     * Serve a re-attach: replay what the ring still holds, and report — exactly —
+     * what it does not.
+     *
+     * The subtraction is the point. `owed` is what the client should have received
+     * since its last serial (from the watermark, which survives ring eviction);
+     * `replayed` is what we can actually hand over. An origin the client never
+     * mentioned is one that appeared while it was away, so everything retained
+     * from it is owed. A `gap` is emitted BEFORE the replay so a consumer reading
+     * in order learns it is behind before it starts processing.
+     */
+    private replayForResume;
+    stats(): EventBusStats;
+    /** Per-route live numbers for the inspect surface + dashboard. */
+    snapshot(): ReadonlyArray<EventRouteSnapshot>;
+    /** Drop every route, listener and buffer. For tests and shutdown. */
+    clear(): void;
+}
+
+export declare interface EventBusOptions {
+    /** This instance's id. Two processes must never share one. */
+    readonly origin: string;
+    /**
+     * Ring depth per route. 64 by default — sized from what comparable products
+     * allow (Ably caps replay at 100 messages / 2 minutes; Supabase at 25), i.e.
+     * tens of messages and minutes. Anything materially larger is a durable queue
+     * with extra steps, and the framework already has one (`ctx.outbox`).
+     */
+    readonly ringSize?: number;
+    /** How long a ring entry stays eligible for replay. 5 minutes by default. */
+    readonly ringTtlMs?: number;
+    /**
+     * Hard ceiling on how many routes retain a ring at once. A route is an
+     * app-controlled cardinality (`{userId}` in a key is one route per user), so
+     * without a ceiling an unbounded key space is an unbounded memory leak in a
+     * long-lived process — the same failure shape as an append-only table with no
+     * sweep, one layer up. Oldest-touched routes are evicted first.
+     */
+    readonly maxRoutes?: number;
+    /** Hand-off to the cross-instance transport. Absent ⇒ single-instance. */
+    readonly publishRemote?: (envelope: EventEnvelope) => void;
+    /**
+     * What a declared event's name means for retention and loss reporting.
+     *
+     * A lookup rather than a field on `subscribe`, because the answer must be the
+     * SAME for every subscriber of one event and for the publisher — a per-call
+     * argument is a per-call opportunity to disagree, and the disagreement would
+     * show up as one client being told it missed messages another was told it did
+     * not. Wired once from the declared events at boot.
+     */
+    readonly deliveryOf?: (event: string) => EventDeliverySemantics | undefined;
+    readonly now?: () => number;
+}
+
+export declare interface EventBusStats {
+    readonly routes: number;
+    readonly subscribers: number;
+    readonly buffered: number;
+}
+
+/** What a subscriber is told. `gap` is only ever emitted with a PROVEN count. */
+export declare type EventDelivery = {
+    readonly kind: 'event';
+    readonly envelope: EventEnvelope;
+    /**
+     * This route's watermark for `envelope.origin` IMMEDIATELY BEFORE this
+     * envelope was accepted — the one number a subscriber cannot infer, and
+     * without which it cannot tell two opposite situations apart.
+     *
+     * Both look identical from a subscriber's seat: an origin absent from the
+     * attach watermark, and a first delivery carrying a high serial.
+     *
+     *   prior > 0  this instance HAD been receiving that origin, so the
+     *              serials between what we forwarded and this one existed
+     *              here and were lost on the way to this subscriber.
+     *   prior = 0  this instance had accepted nothing from that origin on
+     *              this route, so nothing local could have been dropped. A
+     *              replica that started — or joined this event's channel —
+     *              while a peer was already at serial 5000 is in this case.
+     *
+     * Reading the second as the first is what made a freshly-started replica
+     * announce a 5000-message loss to every client on its first delivery.
+     */
+    readonly prior: number;
+} | {
+    readonly kind: 'gap';
+    readonly missed: number;
+    readonly reason: 'buffer' | 'resume';
+};
+
+/** One delivery, as it travels locally and across instances. */
+export declare interface EventEnvelope {
+    /** `tenant · event · key`, NUL-separated — built by `eventRoute`, read with
+     *  `parseEventRoute`. Never construct or split one by hand. */
+    readonly route: string;
+    /** Declared event name, carried separately so a consumer of the raw envelope
+     *  (broadcast bridge, inspect, metrics) needn't re-parse the route. */
+    readonly event: string;
+    /** Publishing instance. Serials are only comparable WITHIN one origin. */
+    readonly origin: string;
+    /** Monotonic per (origin, route). */
+    readonly n: number;
+    readonly emittedAt: number;
+    readonly payload: unknown;
+}
+
+declare type EventListener_2 = (delivery: EventDelivery) => void;
+export { EventListener_2 as EventListener }
+
+export declare const eventMetricTagCacheSizeForTests: () => number;
+
+/** What `publish` needs to know about the caller. */
+export declare interface EventPublishContext {
+    readonly bus: EventBus;
+    /** From the SUBJECT, never from a caller argument. */
+    readonly tenantId: string | null;
+    /**
+     * Defer until commit, when a transaction is open.
+     *
+     * Present ⇒ the caller is inside `transactional()` and the delivery is queued
+     * with the ChangeEvents the transactional view already buffers, so it is
+     * flushed by the same `commitEvents()` that publishes row changes — and
+     * discarded entirely on rollback. Absent ⇒ deliver now.
+     *
+     * A display reacting to a game start the database rolled back is not a race
+     * that is unlikely, it is one that happens on every constraint violation.
+     */
+    readonly deferToCommit?: ((deliver: () => void) => void) | undefined;
+    /**
+     * The DURABLE audience — the workflow-trigger path.
+     *
+     * `publish` is one declaration reaching several audiences, and this is the
+     * seam for the audience that outlives the process: it records the event and
+     * starts whatever workflows are triggered by it. Absent when the app declares
+     * no triggers, so an app that only fans out to clients pays nothing.
+     *
+     * Deliberately fire-and-forget from `publish`'s point of view: a trigger that
+     * fails must not fail the mutation that published, for the same reason a
+     * broker outage does not. The trigger's own delivery row records the failure.
+     */
+    readonly onPublished?: ((eventName: string, payload: unknown, descriptor: unknown) => void) | undefined;
+}
+
+export declare interface EventPublisher {
+    publish<Name extends string, Key extends Schema.Schema.Any, Payload extends Schema.Schema.Any>(descriptor: EventDescriptor<Name, Key, Payload>, key: Schema.Schema.Type<Key>, payload: Schema.Schema.Type<Payload>): AwaitableEffect<EventPublishResult, EventPublishError>;
+}
+
+export declare type EventPublishError = EventPayloadInvalid | EventKeyInvalid | EventPayloadTooLarge;
+
+/**
+ * The `ctx.events.publish` facade, bound to one request's tenant + transaction.
+ *
+ * Typed at the call site from the descriptor alone: `key` and `payload` are both
+ * inferred, so a wrong field name is a `tsc` error where it is written rather
+ * than a handler that never fires.
+ */
+/** What a publish resolves to, in either spelling. */
+export declare interface EventPublishResult {
+    readonly n: number;
+    readonly deferred: boolean;
+}
+
+/** A declared event's live numbers, for the inspect surface. */
+export declare interface EventRouteSnapshot {
+    readonly route: string;
+    readonly event: string;
+    readonly subscribers: number;
+    readonly buffered: number;
+    readonly lastEmittedAt: number | undefined;
+}
+
+/**
+ * The INTERNAL durable-event facade.
+ *
+ * No longer `ctx.events` — an app cannot reach this. `ctx.events.publish` is
+ * the only emitter, and it drives this one as its durable audience, so a
+ * workflow trigger and a client subscriber can never disagree about whether the
+ * event happened.
+ *
+ * The string form survives here, one layer down, because the durable path
+ * matches triggers BY NAME and the name is what a `defineEvent` descriptor
+ * supplies. What was removed is the ability for an app to invent a name that
+ * nothing declared — which is the whole defect.
+ */
 export declare interface EventsAppContext {
     emit<Payload = unknown>(eventName: string, data: Payload, options?: WorkflowEventEmitOptions): Promise<WorkflowEventEmitResult>;
 }
@@ -2280,6 +2738,20 @@ export declare interface EventsFacadeOptions {
     readonly makeId?: (prefix: 'wfe' | 'wfed') => string;
 }
 
+export declare interface EventSubscribeOptions {
+    /**
+     * Where this client left off, per origin. PRESENT means re-attach and the
+     * client is owed continuity; ABSENT means a first attach, which starts empty.
+     *
+     * The distinction cannot be inferred server-side — a reconnecting socket and a
+     * freshly mounted component look identical from here — so the client states
+     * it, and the framework's client does that automatically.
+     */
+    readonly resume?: ReadonlyArray<EventResumePoint> | undefined;
+    /** Descriptor opt-in: deliver what the ring holds even on a FIRST attach. */
+    readonly rewind?: boolean | undefined;
+}
+
 /** Exchange an authorization code (from the callback) for a token set. */
 export declare const exchangeAuthorizationCode: (definition: OAuth2ConnectionDefinition, input: {
     readonly code: string;
@@ -2428,6 +2900,9 @@ export declare const formatServerOnlyLeaks: (leaks: ReadonlyArray<ServerOnlyLeak
 /** Serialise a span's context as a `traceparent` header value. */
 export declare const formatTraceparent: (ctx: TraceContext) => string;
 
+/** The boot warning for unresolved sources, or `undefined` when there are none. */
+export declare const formatUnresolvedSources: (found: ReadonlyArray<UnresolvedSource>) => string | undefined;
+
 /** One captured row change within a mutation invocation. */
 export declare interface ForwardChange {
     readonly table: string;
@@ -2740,6 +3215,47 @@ export { inspectWorkflow }
  */
 export declare const installPolicyGuardResolver: () => void;
 
+/**
+ * The live membership of this deployment, as THIS instance can observe it.
+ *
+ * Transport-agnostic, like the event bus: `announce` is injected and remote
+ * heartbeats arrive through `receive`. That keeps it testable with no broker and
+ * makes the cross-instance wiring one place rather than a concern spread through
+ * the registry.
+ */
+export declare class InstanceMembership {
+    private readonly members;
+    private readonly listeners;
+    private readonly instanceId;
+    private readonly startedAt;
+    private readonly meta;
+    private readonly heartbeatMs;
+    private readonly downAfterMs;
+    private readonly announce;
+    private readonly now;
+    private timer;
+    constructor(options: MembershipOptions);
+    get id(): string;
+    /** Begin announcing, and start expiring the silent. */
+    start(): void;
+    stop(): void;
+    private beat;
+    /**
+     * Take a heartbeat from another instance.
+     *
+     * Our own id echoed back by the broker is ignored: self-liveness is local, and
+     * accepting the echo would let a broker outage look like a self-death.
+     */
+    receive(heartbeat: MembershipHeartbeat): void;
+    /** Drop instances that have gone silent past the threshold. */
+    sweep(): void;
+    /** Everyone this instance currently believes is alive, self included. */
+    list(): ReadonlyArray<MemberSnapshot>;
+    /** Subscribe to membership changes. Returns the unsubscribe. */
+    onChange(listener: MembershipListener): () => void;
+    private emit;
+}
+
 /** Fire every registered interrupt for `clientId` (called on disconnect). */
 export declare const interruptConnectionStreams: (clientId: number) => void;
 
@@ -2820,6 +3336,20 @@ export declare const isSafeToApply: (current: Record<string, unknown> | null | u
 
 export declare const isScheduleDefinition: (v: unknown) => v is BrandedScheduleDefinition;
 
+/**
+ * Did this change soft-delete the row?
+ *
+ * A soft delete is NOT a `delete` event — it is an `update` that sets
+ * `deletedAt`. That distinction is why the first version of `onSoftDelete` was
+ * inert in every case: the matcher only looked at `op === 'delete'`, which a
+ * soft delete never is, so the option existed and could not fire. Exactly the
+ * defect this whole round was about, one level down.
+ *
+ * The transition matters, not the value: a row that was already deleted and is
+ * updated again must not re-fire the rule.
+ */
+export declare const isSoftDelete: (change: PluginRefChange) => boolean;
+
 /** A freshly issued key — `token` is shown ONCE and never stored in clear. */
 export declare interface IssuedApiKey {
     readonly id: string;
@@ -3101,6 +3631,17 @@ export declare const makeAppAccess: (subject: Subject) => AppAccess;
  *  fall back to `database`. */
 export declare const makeAsyncKv: ({ store, env }: KvFacadeOptions) => Promise<KvFacade>;
 
+/**
+ * Detect a serial jump per origin, and report it as a proven count.
+ *
+ * Stateful across one client's stream, which is why it is built per
+ * subscription rather than shared.
+ */
+export declare const makeBufferGapDetector: (attachWatermark?: ReadonlyMap<string, number>) => (event: {
+    readonly origin: string;
+    readonly n: number;
+}, prior?: number) => number;
+
 /**
  * Build a SpanProcessor that maps every finished span to a flat record
  * and hands it to `onSpanEnd`. The callback must not throw (a thrown
@@ -3151,6 +3692,8 @@ export declare const makeDisconnectConnectionExecutor: (deps: ConnectionBuiltinD
  */
 export declare const makeEffectStoreLayer: (store: MutationStore) => Layer.Layer<EffectStore>;
 
+export declare const makeEventPublisher: (ctx: EventPublishContext) => EventPublisher;
+
 export declare const makeEventsFacade: (options: EventsFacadeOptions) => EventsAppContext;
 
 /** Convenience: derive a key from a passphrase and build the cipher. */
@@ -3387,6 +3930,77 @@ export declare const materializeIvm: (shape: AggregateShape, state: IvmState) =>
     readonly value: number | null;
 }>;
 
+/** Told when the membership changes. `restarted` is a `left` + `joined` pair
+ *  for one id, reported as such so a consumer drops the old state rather than
+ *  resuming it. */
+export declare type MembershipEvent = {
+    readonly kind: 'joined';
+    readonly instanceId: string;
+    readonly startedAt: number;
+} | {
+    readonly kind: 'left';
+    readonly instanceId: string;
+    readonly reason: 'silent';
+} | {
+    readonly kind: 'restarted';
+    readonly instanceId: string;
+    readonly startedAt: number;
+};
+
+/** What one instance broadcasts about itself. */
+export declare interface MembershipHeartbeat {
+    readonly instanceId: string;
+    /**
+     * When this PROCESS started, as the sender's own epoch ms.
+     *
+     * Carried as an IDENTITY, never compared to our clock. Its job is to make a
+     * restart distinguishable from a hiccup: an instance that comes back with a
+     * NEW `startedAt` is a fresh process whose owned state is gone, so a consumer
+     * must drop what it held for the old one rather than resume it. A returning
+     * instance with the SAME value only ever missed a few beats.
+     */
+    readonly startedAt: number;
+    /** Free-form, for a dashboard: region, version, pod name. */
+    readonly meta?: Readonly<Record<string, string | number>> | undefined;
+}
+
+export declare type MembershipListener = (event: MembershipEvent) => void;
+
+export declare interface MembershipOptions {
+    readonly instanceId: string;
+    /** This process's start time. Defaults to now. */
+    readonly startedAt?: number;
+    readonly meta?: Readonly<Record<string, string | number>>;
+    /**
+     * How often to announce. 5 s by default — frequent enough that a death is
+     * noticed inside a page load, cheap enough that a hundred replicas produce
+     * twenty messages a second between them.
+     */
+    readonly heartbeatMs?: number;
+    /**
+     * Silence after which an instance is PRESUMED down. Default 3× the heartbeat.
+     *
+     * Three missed beats rather than one, because a single missed beat is a GC
+     * pause or a broker hiccup, and evicting on it would make a healthy cluster
+     * flap — every flap dropping and re-adding that instance's owned state, which
+     * a presence roster shows as everyone briefly leaving and coming back.
+     */
+    readonly downAfterMs?: number;
+    /** Send a heartbeat onto the transport. Absent ⇒ single-instance. */
+    readonly announce?: (heartbeat: MembershipHeartbeat) => void;
+    readonly now?: () => number;
+}
+
+export declare interface MemberSnapshot {
+    readonly instanceId: string;
+    readonly startedAt: number;
+    readonly meta: Readonly<Record<string, string | number>> | undefined;
+    /** Our clock, when we last heard from it. Never the sender's. */
+    readonly lastHeardAt: number;
+    /** True for this process. */
+    readonly self: boolean;
+}
+
 /** In-memory store (tests + single-process dev). */
 export declare const memoryApiKeyStore: () => ApiKeyStore;
 
@@ -3943,6 +4557,34 @@ export declare const payloadPropertyNames: (schema: Schema.Schema.Any) => {
     readonly optional: ReadonlyArray<string>;
 };
 
+/** A change as the post-commit channel reports it. */
+export declare interface PluginRefChange {
+    readonly table: string;
+    readonly op: 'insert' | 'update' | 'delete';
+    readonly rowId: string;
+    readonly tenantId?: string | null;
+    /** The row before, when there was one — used to spot a soft delete. */
+    readonly old?: Record<string, unknown> | null;
+    /** The row after, when there is one. */
+    readonly new?: Record<string, unknown> | null;
+}
+
+/** One resolved rule: "when <targetTable> loses a row, do <policy> to <table.column>". */
+export declare interface PluginRefRule {
+    readonly table: string;
+    readonly column: string;
+    readonly targetTable: string;
+    readonly policy: PluginRefOrphanPolicy;
+    readonly onSoftDelete: boolean;
+}
+
+/** The store surface the enforcement needs. */
+export declare interface PluginRefStore {
+    query: (descriptor: unknown) => Promise<ReadonlyArray<Record<string, unknown>>>;
+    update: (table: string, id: string, patch: Record<string, unknown>) => Promise<unknown>;
+    delete: (table: string, id: string) => Promise<unknown>;
+}
+
 /** The 3-arg signature a plugin sees on its bind-ctx. */
 export declare type PluginScheduleCoordinated = (name: string, intervalMs: number, effect: () => void | Promise<void>) => CoordinatedScheduleHandle;
 
@@ -4063,6 +4705,17 @@ export declare interface PublicApiKey {
     readonly metadata?: Readonly<Record<string, unknown>> | null;
 }
 
+/**
+ * Validate, size-check and publish one event.
+ *
+ * Returns the assigned serial so a caller (and the tests) can observe ordering
+ * without reaching into the bus.
+ */
+export declare const publishEvent: <Name extends string, Key extends Schema.Schema.Any, Payload extends Schema.Schema.Any>(ctx: EventPublishContext, descriptor: EventDescriptor<Name, Key, Payload>, key: Schema.Schema.Type<Key>, payload: Schema.Schema.Type<Payload>) => Effect.Effect<{
+    readonly n: number;
+    readonly deferred: boolean;
+}, EventPublishError>;
+
 /** A typed builder or its descriptor — the single-row terminals accept either,
  *  so a call site never has to reach for `.descriptor` just to use them. */
 export declare type QueryLike<R = Row_5> = QueryDescriptor<R> | {
@@ -4231,6 +4884,19 @@ export declare interface RecordedSample {
     readonly status: 'ok' | 'error';
 }
 
+/** `count` deliveries handed to subscribers of `event`. */
+export declare const recordEventDelivered: (event: string, count?: number) => void;
+
+/** `count` deliveries PROVABLY lost — `buffer` (a slow consumer) or `resume`
+ *  (a re-attach older than the ring). Never called with a guess. */
+export declare const recordEventDropped: (event: string, reason: "buffer" | "resume", count?: number) => void;
+
+/** One publish of `event`. */
+export declare const recordEventPublished: (event: string) => void;
+
+/** Subscriber attached (+1) or detached (-1). */
+export declare const recordEventSubscribers: (event: string, delta: number) => void;
+
 /**
  * Record one framework sample into the Effect metric registry. Synchronous —
  * metric updates are pure, so `runSync` is cheap and safe to call from the
@@ -4238,6 +4904,15 @@ export declare interface RecordedSample {
  */
 export declare const recordSample: (s: RecordedSample) => void;
 
+/**
+ * Record one schedule firing into the registry: the run counter (by name +
+ * status), the duration histogram, and — on success — the last-success gauge.
+ * Synchronous, like the other recorders (metric updates are pure). Called from
+ * the scheduler's success + failure arms so every cron in every app is covered
+ * without per-handler wiring.
+ */
+export declare const recordScheduleRun: (r: ScheduleRunRecord) => void;
+
 /** Move the live-subscriptions gauge for `label`'s tag by `delta` (+1 open, -1 close). */
 export declare const recordSubscriptionActive: (label: string, delta: number) => void;
 
@@ -4259,6 +4934,14 @@ export declare const recordTimelineEvent: (change: CdcChange & {
     readonly tenantId?: string | null;
 }) => void;
 
+/**
+ * Record one workflow run's terminal outcome: the run counter (by name + status),
+ * the duration histogram, and — on success — the last-success gauge. Synchronous,
+ * like the other recorders. Called from the workflow run-recording seam through an
+ * injected hook so `@voltro/workflow` keeps its no-`@voltro/runtime`-dep boundary.
+ */
+export declare const recordWorkflowRun: (r: WorkflowRunRecord) => void;
+
 /**
  * Strip `redact` columns from a set of rows. Exposed on its own so a hand-written
  * handler that isn't a plain CRUD read can still redact declaratively and be
@@ -4406,6 +5089,7 @@ export declare interface RegistryTableLike {
          * it. MariaDB/Postgres reject an explicit value, so the MutationStore
          * strips any the caller supplied before the INSERT reaches the dialect.
          */
+        readonly versionColumn?: boolean;
         readonly generatedAs?: {
             readonly expr: string;
             readonly stored: boolean;
@@ -4626,6 +5310,9 @@ export declare const resetComputedQueryCacheWarnings: () => void;
 /** Test/dev-only — clear ALL overrides. Don't call from app code. */
 export declare const _resetConnectionSubjectsForTest: () => void;
 
+/** Test seams for the tag-cache guard — the cache is module-private otherwise. */
+export declare const resetEventMetricTagCacheForTests: () => void;
+
 /** Drop everything recorded. For tests; not called by the runtime. */
 export declare const resetObservedGraph: () => void;
 
@@ -5077,6 +5764,14 @@ export declare interface RpcServerOptions<Rpcs extends Rpc.Any> {
     readonly maxRpcBodyBytes?: number;
 }
 
+/**
+ * Rules that apply to one change, or an empty list.
+ *
+ * Exported separately from the execution so the matching is testable without a
+ * store: which rules fire is the part with the edge cases.
+ */
+export declare const rulesFor: (rules: ReadonlyArray<PluginRefRule>, change: PluginRefChange) => ReadonlyArray<PluginRefRule>;
+
 /**
  * Run `fn` with `SubjectService` bound to a `system` subject and a
  * system-scoped fluent `ctx.store`. Returns whatever `fn` returns.
@@ -5502,6 +6197,16 @@ export declare interface SchedulerLogger {
     debug?: (msg: string, fields?: Record<string, unknown>) => void;
 }
 
+export declare interface ScheduleRunRecord {
+    readonly name: string;
+    readonly status: 'succeeded' | 'failed' | 'skipped' | 'missed';
+    readonly durationMs: number;
+    /** UNIX SECONDS of completion — set only on a success (drives the last-success
+     *  gauge). Omit for a non-success; the gauge is deliberately not moved then, so
+     *  it keeps pointing at the last time the job actually worked. */
+    readonly completedAtSec?: number;
+}
+
 /** Trigger driver — `self` runs an in-app supervised timer; `external`
  *  exposes an HTTP endpoint that an outside scheduler (k8s CronJob,
  *  AWS EventBridge, GCP Cloud Scheduler, …) invokes. */
@@ -5530,6 +6235,8 @@ export declare interface SchemaInfo {
      * on every UPDATE against the merged post-update row.
      */
     readonly computedFields: ReadonlyMap<string, (row: Readonly<Record<string, unknown>>) => unknown>;
+    /** The column marked `.version()`, when the table declares one. */
+    readonly versionColumn?: string;
     /**
      * DB-generated columns (`generatedAs`). The MutationStore strips any
      * caller-supplied value for these before the INSERT — the engine computes
@@ -5579,6 +6286,10 @@ export declare interface SchemaRegistry {
     /** Convenience: `hasMixin(table, VOLTRO_AUDIT_MIXIN_ID)`. */
     hasAudit(table: string): boolean;
     hasSoftDelete(table: string): boolean;
+    /** True when the table carries `expires()`. Reads filter expired rows on
+     *  EVERY dialect from this flag — the postgres-only sweep is a separate,
+     *  optional half. */
+    hasExpires(table: string): boolean;
     hasTenant(table: string): boolean;
     /** Field-existence check — used to skip stamping a column that the
      *  table doesn't actually declare (extra defensive). */
@@ -5606,6 +6317,14 @@ export declare interface SchemaRegistry {
      * overwrites whatever the caller passed for that column.
      */
     computedFields(table: string): ReadonlyMap<string, (row: Readonly<Record<string, unknown>>) => unknown>;
+    /**
+     * The table's optimistic-concurrency column, or `undefined`.
+     *
+     * Resolved ONCE at registration rather than scanned per write: an update is
+     * the hot path, and a per-write `Object.entries` over every column of every
+     * table is the kind of cost that only shows up under load.
+     */
+    versionColumn(table: string): string | undefined;
     /**
      * DB-generated columns (`generatedAs`) for a table. Empty set if none.
      * Read by MutationStore.stampedForInsert to STRIP any caller-supplied
@@ -6056,6 +6775,26 @@ export declare interface SubscribeContext {
      * workflow" belongs in a `*.reaction.tsx`, whose `act` is crash-safe.
      */
     readonly store: FluentStore;
+    /**
+     * Publish a declared event from a table change — the bridge between the two
+     * axes.
+     *
+     * A row changing and a thing happening are not the same statement, and most
+     * of the time only one of them is what a client cares about: nobody watches
+     * `attendance` rows, they watch "attendance changed". Without this, an app
+     * with a table-derived event has to publish from every mutation that touches
+     * the table and remember to do it in the next one too — which is the
+     * fail-open-by-omission shape a declaration exists to remove.
+     *
+     * Present only when the app declares at least one `defineEvent`, so reaching
+     * for it in an app with none is a type error rather than a runtime undefined.
+     *
+     * BEST-EFFORT, like everything else in a subscriber: this fires AFTER the
+     * commit, so there is no transaction to couple to and a failed publish cannot
+     * roll anything back. If the event must not be lost, publish it from the
+     * mutation instead — there it rides the commit.
+     */
+    readonly publish?: EventPublisher['publish'];
 }
 
 /** Event shape passed to a subscriber handler. Same as the
@@ -6483,7 +7222,36 @@ export declare interface TransactionalStore {
     transactional<T>(work: (tx: unknown) => Promise<T>): Promise<T>;
 }
 
-export declare const triggerWorkflow: <EventPayload = unknown, WorkflowPayload = EventPayload>(spec: Omit<WorkflowEventTriggerDefinition<EventPayload, WorkflowPayload>, "_tag">) => WorkflowEventTriggerDefinition<EventPayload, WorkflowPayload>;
+/**
+ * Declare a workflow trigger.
+ *
+ * TWO forms, and the descriptor one is the one to use:
+ *
+ * ```ts
+ * triggerWorkflow({ on: gameStarted, workflow: 'postGameReport' })   // typed
+ * triggerWorkflow({ event: 'games.started', workflow: 'postGameReport' })  // string
+ * ```
+ *
+ * `on:` takes a `defineEvent` descriptor and reads its NAME, so the trigger and
+ * the producer cannot drift: rename the event and this call site moves with it,
+ * where the string form silently stops matching and the workflow simply never
+ * runs again. That failure is exactly what a consumer reported having with their
+ * own string channels — `on-game-scores` beside `games/evo5/on-game-scores`,
+ * both live, one dead since the day it was written — and it is the reason the
+ * string form is going away rather than being kept as an alternative.
+ *
+ * It is ADDITIVE today on purpose. Shipping the descriptor form with the event
+ * primitive means a third string namespace never comes into existence even
+ * briefly; removing the string form is a separate, breaking change with its own
+ * codemod, and nothing here has to be undone for it.
+ */
+export declare const triggerWorkflow: <EventPayload = unknown, WorkflowPayload = EventPayload>(spec: Omit<WorkflowEventTriggerDefinition<EventPayload, WorkflowPayload>, "_tag"> | (Omit<WorkflowEventTriggerDefinition<EventPayload, WorkflowPayload>, "_tag" | "event"> & {
+    /** A declared event. Its `name` becomes the matched event. */
+    readonly on: {
+        readonly kind: "event";
+        readonly name: string;
+    };
+})) => WorkflowEventTriggerDefinition<EventPayload, WorkflowPayload>;
 
 /**
  * Atomically claim a pending wakeup for waking — CAS `pending → fired`.
@@ -6610,6 +7378,27 @@ export declare class UndoStack<E> {
     };
 }
 
+/** One `source:` entry that resolves to no declared table. */
+export declare interface UnresolvedSource {
+    /** The procedure that declares it. */
+    readonly procedure: string;
+    /** The name as written. */
+    readonly source: string;
+    /** A declared table whose name is close — the rename case, usually. */
+    readonly didYouMean: string | undefined;
+}
+
+/**
+ * Every `source:` across `procedures` that names no declared table.
+ *
+ * `declared` is the table-name set the boot already built. Procedures with no
+ * `source` are skipped — reactivity is opt-in and its absence is not a defect.
+ */
+export declare const unresolvedSources: (procedures: ReadonlyArray<{
+    readonly name: string;
+    readonly source: string | ReadonlyArray<string> | undefined;
+}>, declared: ReadonlySet<string>) => ReadonlyArray<UnresolvedSource>;
+
 export declare class UpdateBuilder {
     private readonly backend;
     private readonly scope;
@@ -6672,6 +7461,11 @@ export declare const visibleRows: <Row extends {
  */
 export declare const VOLTRO_AUDIT_MIXIN_ID: "voltro/audit";
 
+/** Re-declared here for the same reason the soft-delete id is: the registry
+ *  must not import the mixin (which pulls its column builders into every
+ *  consumer). Kept in step by `expiresMixinId.test.ts`. */
+export declare const VOLTRO_EXPIRES_MIXIN_ID: "voltro/expires";
+
 export declare const VOLTRO_SOFT_DELETE_MIXIN_ID: "voltro/softDelete";
 
 export declare const VOLTRO_TENANT_MIXIN_ID: "voltro/tenant";
@@ -6955,6 +7749,17 @@ export declare interface WorkflowFacadeOptions {
      *  Inspect HTTP + the `voltro workflows retry` CLI delegate to the same
      *  implementation. */
     readonly retry?: (runId: string, options: WorkflowRetryOptions | undefined) => Promise<WorkflowRetryResult>;
+    /** Backs {@link WorkflowsAppContext.redrive}. Supplied by the CLI's facade
+     *  builder, which owns the runs/steps store query + the cluster journal
+     *  adapter. Inspect HTTP + `voltro workflows redrive` delegate to the same
+     *  implementation. */
+    readonly redrive?: (runId: string) => Promise<WorkflowRedriveResult>;
+    /** Fired (fire-and-forget) right after a workflow is ENQUEUED — a start,
+     *  child, or run. The CLI wires this to a cross-replica "wake" broadcast so
+     *  the replica that OWNS the new run's shard polls immediately instead of
+     *  waiting for its next storage tick. No-op when unset (single replica / no
+     *  broker → the poll interval covers it). */
+    readonly onEnqueue?: () => void;
 }
 
 export declare interface WorkflowLayerExecutionContext {
@@ -6995,6 +7800,16 @@ export declare class WorkflowPayloadError extends Error {
     missingFields: ReadonlyArray<string>, detail: string);
 }
 
+/** Result of {@link WorkflowsAppContext.redrive} — whether the failed run's
+ *  durable journal was re-driven, how many failed step attempts were reset so
+ *  they re-execute, and a `reason` when it declined (no journal / still
+ *  running / already succeeded). */
+export declare interface WorkflowRedriveResult {
+    readonly redriven: boolean;
+    readonly activitiesReset: number;
+    readonly reason: string | null;
+}
+
 /** Options for {@link WorkflowsAppContext.retry}. */
 export declare interface WorkflowRetryOptions {
     /** Re-run the workflow against this payload instead of the original
@@ -7016,6 +7831,11 @@ export declare interface WorkflowRunListFilter {
     readonly workflowName?: string;
     readonly tag?: string;
     readonly status?: WorkflowRunRecordStatus;
+    /** The DEAD-LETTER view: failed runs an operator has NOT yet discarded
+     *  (`status = 'failed' AND discardedAt IS NULL`). Since the framework applies no
+     *  retry, a `failed` run is terminal — this is the queue of unhandled failures.
+     *  Combines with the other filters (e.g. by `workflowName`). */
+    readonly deadLettered?: boolean;
     readonly limit?: number;
     readonly offset?: number;
 }
@@ -7024,6 +7844,16 @@ export declare interface WorkflowRunOptions {
     /* Excluded from this release type: callerContext */
 }
 
+export declare interface WorkflowRunRecord {
+    readonly name: string;
+    /** Terminal outcome only. `failed` is the dead-letter state (no framework retry). */
+    readonly status: 'succeeded' | 'failed';
+    readonly durationMs: number;
+    /** UNIX SECONDS of completion — set only on success (drives the last-success
+     *  gauge). Omit on failure so the gauge keeps pointing at the last real success. */
+    readonly completedAtSec?: number;
+}
+
 /** Persisted run lifecycle states recorded in `_voltro_workflow_runs`.
  *  Distinct from {@link WorkflowRunStatus} (which is derived from a live
  *  engine poll and carries `succeeded`/`unknown`); this enum matches the
@@ -7063,6 +7893,9 @@ export declare interface WorkflowRunSummary<Payload = unknown, Output = unknown>
     readonly durationMs: number | null;
     readonly traceId: string | null;
     readonly parentExecutionId: string | null;
+    /** When set, an operator has acknowledged this (failed) run — it is off the
+     *  dead-letter view. Null = unacknowledged. See `WorkflowRunListFilter.deadLettered`. */
+    readonly discardedAt: Date | null;
 }
 
 export declare interface WorkflowsAppContext {
@@ -7088,6 +7921,14 @@ export declare interface WorkflowsAppContext {
      *  workflow by tag and re-executes it; pass `payloadOverride` to replay
      *  against a corrected input. */
     retry(runId: string, options?: WorkflowRetryOptions): Promise<WorkflowRetryResult>;
+    /** Re-drive a terminally-`failed` run from the step it died on, reusing
+     *  its durable journal — the counterpart to {@link retry} (fresh execution,
+     *  empty journal) and to {@link resume} (which only re-drives a *suspended*
+     *  run). Addressed by run id (`wfrun_…`). Completed steps replay from the
+     *  journal; only the failed steps re-execute. Fix the downstream cause
+     *  first, then redrive. Refuses a run that is not a not-yet-discarded
+     *  failure. */
+    redrive(runId: string): Promise<WorkflowRedriveResult>;
 }
 
 export declare interface WorkflowSignalTarget {