pipework 0.8.1 → 0.8.4

package/dist/trace/runtime/step-buffer.d.ts

@@ -0,0 +1,139 @@
+import { type StepError } from './step-error.js';
+import type { MetaTouch } from './step-meta.js';
+/** A `trace_step` row staged in memory, ready to be flushed. */
+export interface PendingStep {
+    readonly id: string;
+    readonly traceDay: string;
+    readonly traceId: string;
+    readonly seq: number;
+    readonly parentStepId: string | null;
+    readonly flowStepRef: string;
+    readonly status: 'ok' | 'error';
+    readonly startedAt: Date;
+    readonly completedAt: Date;
+    readonly durationMicros: bigint;
+    /**
+     * Tier-2 input capture (Q5): one bounded-serialized payload per parameter,
+     * in declaration order. `null` when the transformer emitted no capture
+     * metadata for this step or the `captureInputs` kill-switch is off.
+     */
+    readonly capturedInputs: readonly unknown[] | null;
+    readonly error: StepError | null;
+}
+/** A step that has started but not yet completed — the handle `complete` settles. */
+export interface BegunStep {
+    readonly seq: number;
+    readonly stepId: string;
+    readonly parentStepId: string | null;
+    readonly flowStepRef: string;
+    readonly startedAt: Date;
+    readonly startHrTime: bigint;
+    /** Captured at begin time so a mutating impl can't change what the row records. */
+    readonly capturedInputs: readonly unknown[] | null;
+    /**
+     * `@touches Entity:verb` targets baked into this step's meta. Empty means
+     * no audit projection — the executor takes the vanilla-DML branch and
+     * `__flowStep`'s completion path emits no read-touches audit row.
+     */
+    readonly touches: readonly MetaTouch[];
+    /**
+     * Set to true by the executor when it commits a `pipe.*` write under this
+     * step. `__flowStep` reads this at completion to decide whether to emit the
+     * read-touches `audit_record` row (only when `touches.length > 0` and no
+     * write happened). The CTE branch handled the audit itself.
+     */
+    wroteForAudit: boolean;
+}
+/**
+ * The active-step handle the write executor reads to compile its CTE. Captures
+ * everything the `audit_inserts` SELECT needs from the step's runtime context:
+ * the step id and trace id that link the audit row back to the source step,
+ * the partition day, the bounded-serialized captured inputs, and the active
+ * touches. Returned by `StepBuffer.currentStep()` only while a step is open
+ * for audit (touches present); otherwise `null` so the executor falls through
+ * to vanilla DML.
+ */
+export interface ActiveAuditStep {
+    readonly traceId: string;
+    readonly traceDay: string;
+    readonly stepId: string;
+    readonly touches: readonly MetaTouch[];
+    readonly capturedInputs: readonly unknown[] | null;
+    /** Called by the executor right before it returns — flips `wroteForAudit` on the underlying BegunStep. */
+    markWrote(): void;
+}
+export interface StepBufferParams {
+    readonly traceId: string;
+    /** The parent trace's `openedDay` — the partition every step row lands in. */
+    readonly traceDay: string;
+    /**
+     * The Q7 step cap. The `seq` that first exceeds it trips truncation;
+     * `Infinity` disables the cap (no `structuralMax` resolved yet).
+     */
+    readonly cap: number;
+    /**
+     * The Q5 input-capture kill-switch, resolved at trace open from
+     * `instance.config.trace.captureInputs`. When `false`, every step in this
+     * trace stages `capturedInputs: null` regardless of what the transformer
+     * emitted — Tier-1 capture is unaffected.
+     */
+    readonly captureInputs: boolean;
+}
+export declare class StepBuffer {
+    private readonly traceId;
+    private readonly traceDay;
+    private readonly cap;
+    readonly captureInputs: boolean;
+    private seq;
+    private currentStepId;
+    /**
+     * The active begun-step at the deepest open nesting level. `__flowStep`
+     * pushes on `begin` and pops on `complete`; the write executor reads the
+     * top of the stack through `currentStep()` to compile its audit CTE.
+     *
+     * The stack pairs with `currentStepId` — both describe step nesting — but
+     * keeps the full `BegunStep` reference so the executor and the read-touches
+     * emitter can reach `touches` and `capturedInputs` without a second lookup.
+     */
+    private readonly active;
+    private pending;
+    private truncatedAtSeqValue;
+    private truncationDoneValue;
+    constructor(params: StepBufferParams);
+    /** True once the step cap has been blown — the trace records no further steps. */
+    get truncated(): boolean;
+    /** The `seq` that tripped truncation, for `trace.truncated_at_seq`. */
+    get truncatedAtSeq(): number | null;
+    /**
+     * Settles when `truncateTrace`'s side effects have landed (flush + status
+     * `UPDATE`). `closeTrace` awaits this before its copy-on-error so the cold
+     * row reflects `truncated_at_seq`. `null` when the trace was never truncated.
+     */
+    get truncationDone(): Promise<void> | null;
+    /** Records the truncation's settle handle. `truncateTrace` calls this once. */
+    markTruncationDone(promise: Promise<void>): void;
+    /**
+     * Opens a step: assigns its `seq`, mints its id, and nests it under the step
+     * currently executing. Returns `null` when this step is the one that blows
+     * the cap — the caller runs the implementation untraced from here on.
+     *
+     * `capturedInputs` is the bounded-serialized projection of the step's args
+     * (built by `__flowStep` from `meta.capture`), or `null` for Tier-1-only.
+     * `touches` is the `@touches Entity:verb` set baked into the step's meta,
+     * or empty when the step has no audit projection.
+     */
+    begin(flowStepRef: string, capturedInputs: readonly unknown[] | null, touches?: readonly MetaTouch[]): BegunStep | null;
+    /**
+     * The active step's audit handle, or `null` when there is no open step or
+     * the open step has no `@touches`. The write executor uses this to decide:
+     * `null` → vanilla DML; non-null → compile the `audit_inserts` CTE. The
+     * returned handle's `markWrote()` flips `wroteForAudit` so `__flowStep`
+     * suppresses the read-touches emission at step completion.
+     */
+    currentStep(): ActiveAuditStep | null;
+    /** Settles a begun step: stamps its outcome and timing, stages the row, unnests. */
+    complete(begun: BegunStep, status: 'ok' | 'error', thrown: unknown): void;
+    /** Removes and returns every staged row — the buffer is empty afterwards. */
+    drain(): PendingStep[];
+}
+//# sourceMappingURL=step-buffer.d.ts.map

package/dist/trace/runtime/step-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-buffer.d.ts","sourceRoot":"","sources":["../../../src/trace/runtime/step-buffer.ts"],"names":[],"mappings":"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"}

package/dist/trace/runtime/step-buffer.js

@@ -0,0 +1,140 @@
+// The per-trace step buffer. Every Flow that runs under tracing carries one;
+// `__flowStep` records into it and the trace's close drains it to the database
+// in a single batch. The buffer is in-memory and single-trace: a branch opens a
+// child Flow with its own buffer, so the rows here never interleave with
+// another trace's.
+//
+// Three pieces of mutable state, all owned here so `__flowStep` stays a thin
+// wrapper: the `seq` counter (spawn order within the trace), `currentStepId`
+// (the step a nested step records as its parent), and the truncation latch
+// (Q7 — once the step cap is blown the buffer goes no-op for the rest of the
+// trace, mirroring the off-the-traced-path code path exactly).
+import { randomUUID } from 'node:crypto';
+import { projectStepError } from './step-error.js';
+export class StepBuffer {
+    traceId;
+    traceDay;
+    cap;
+    captureInputs;
+    seq = 0;
+    currentStepId = null;
+    /**
+     * The active begun-step at the deepest open nesting level. `__flowStep`
+     * pushes on `begin` and pops on `complete`; the write executor reads the
+     * top of the stack through `currentStep()` to compile its audit CTE.
+     *
+     * The stack pairs with `currentStepId` — both describe step nesting — but
+     * keeps the full `BegunStep` reference so the executor and the read-touches
+     * emitter can reach `touches` and `capturedInputs` without a second lookup.
+     */
+    active = [];
+    pending = [];
+    truncatedAtSeqValue = null;
+    truncationDoneValue = null;
+    constructor(params) {
+        this.traceId = params.traceId;
+        this.traceDay = params.traceDay;
+        this.cap = params.cap;
+        this.captureInputs = params.captureInputs;
+    }
+    /** True once the step cap has been blown — the trace records no further steps. */
+    get truncated() {
+        return this.truncatedAtSeqValue !== null;
+    }
+    /** The `seq` that tripped truncation, for `trace.truncated_at_seq`. */
+    get truncatedAtSeq() {
+        return this.truncatedAtSeqValue;
+    }
+    /**
+     * Settles when `truncateTrace`'s side effects have landed (flush + status
+     * `UPDATE`). `closeTrace` awaits this before its copy-on-error so the cold
+     * row reflects `truncated_at_seq`. `null` when the trace was never truncated.
+     */
+    get truncationDone() {
+        return this.truncationDoneValue;
+    }
+    /** Records the truncation's settle handle. `truncateTrace` calls this once. */
+    markTruncationDone(promise) {
+        this.truncationDoneValue = promise;
+    }
+    /**
+     * Opens a step: assigns its `seq`, mints its id, and nests it under the step
+     * currently executing. Returns `null` when this step is the one that blows
+     * the cap — the caller runs the implementation untraced from here on.
+     *
+     * `capturedInputs` is the bounded-serialized projection of the step's args
+     * (built by `__flowStep` from `meta.capture`), or `null` for Tier-1-only.
+     * `touches` is the `@touches Entity:verb` set baked into the step's meta,
+     * or empty when the step has no audit projection.
+     */
+    begin(flowStepRef, capturedInputs, touches = []) {
+        const seq = ++this.seq;
+        if (seq > this.cap) {
+            this.truncatedAtSeqValue = seq;
+            return null;
+        }
+        const stepId = randomUUID();
+        const begun = {
+            seq,
+            stepId,
+            parentStepId: this.currentStepId,
+            flowStepRef,
+            startedAt: new Date(),
+            startHrTime: process.hrtime.bigint(),
+            capturedInputs,
+            touches,
+            wroteForAudit: false,
+        };
+        this.currentStepId = stepId;
+        this.active.push(begun);
+        return begun;
+    }
+    /**
+     * The active step's audit handle, or `null` when there is no open step or
+     * the open step has no `@touches`. The write executor uses this to decide:
+     * `null` → vanilla DML; non-null → compile the `audit_inserts` CTE. The
+     * returned handle's `markWrote()` flips `wroteForAudit` so `__flowStep`
+     * suppresses the read-touches emission at step completion.
+     */
+    currentStep() {
+        const top = this.active[this.active.length - 1];
+        if (top === undefined || top.touches.length === 0)
+            return null;
+        return {
+            traceId: this.traceId,
+            traceDay: this.traceDay,
+            stepId: top.stepId,
+            touches: top.touches,
+            capturedInputs: top.capturedInputs,
+            markWrote: () => { top.wroteForAudit = true; },
+        };
+    }
+    /** Settles a begun step: stamps its outcome and timing, stages the row, unnests. */
+    complete(begun, status, thrown) {
+        this.currentStepId = begun.parentStepId;
+        const idx = this.active.lastIndexOf(begun);
+        if (idx !== -1)
+            this.active.splice(idx, 1);
+        this.pending.push({
+            id: begun.stepId,
+            traceDay: this.traceDay,
+            traceId: this.traceId,
+            seq: begun.seq,
+            parentStepId: begun.parentStepId,
+            flowStepRef: begun.flowStepRef,
+            status,
+            startedAt: begun.startedAt,
+            completedAt: new Date(),
+            durationMicros: (process.hrtime.bigint() - begun.startHrTime) / 1000n,
+            capturedInputs: begun.capturedInputs,
+            error: status === 'error' ? projectStepError(thrown) : null,
+        });
+    }
+    /** Removes and returns every staged row — the buffer is empty afterwards. */
+    drain() {
+        const drained = this.pending;
+        this.pending = [];
+        return drained;
+    }
+}
+//# sourceMappingURL=step-buffer.js.map

package/dist/trace/runtime/step-buffer.js.map

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

package/dist/trace/runtime/step-error.d.ts

@@ -0,0 +1,8 @@
+export interface StepError {
+    readonly name: string;
+    readonly message: string;
+    readonly stack: string | null;
+}
+/** The `trace_step.error` projection of a thrown value. */
+export declare function projectStepError(thrown: unknown): StepError;
+//# sourceMappingURL=step-error.d.ts.map

package/dist/trace/runtime/step-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-error.d.ts","sourceRoot":"","sources":["../../../src/trace/runtime/step-error.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CAC9B;AAED,2DAA2D;AAC3D,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAK3D"}

package/dist/trace/runtime/step-error.js

@@ -0,0 +1,13 @@
+// Tier-1 error capture: the JSON projection of a thrown value for the
+// `trace_step.error` column. Errors are always captured (Tier 1) — unlike
+// inputs, an error carries no tenant data of its own, only the failure shape a
+// reader needs. A non-`Error` throw still gets a record so the step is never
+// silently marked failed with nothing to show.
+/** The `trace_step.error` projection of a thrown value. */
+export function projectStepError(thrown) {
+    if (thrown instanceof Error) {
+        return { name: thrown.name, message: thrown.message, stack: thrown.stack ?? null };
+    }
+    return { name: 'NonError', message: String(thrown), stack: null };
+}
+//# sourceMappingURL=step-error.js.map

package/dist/trace/runtime/step-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-error.js","sourceRoot":"","sources":["../../../src/trace/runtime/step-error.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,0EAA0E;AAC1E,+EAA+E;AAC/E,6EAA6E;AAC7E,+CAA+C;AAQ/C,2DAA2D;AAC3D,MAAM,UAAU,gBAAgB,CAAC,MAAe;IAC9C,IAAI,MAAM,YAAY,KAAK,EAAE,CAAC;QAC5B,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,IAAI,IAAI,EAAE,CAAA;IACpF,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAA;AACnE,CAAC"}

package/dist/trace/runtime/step-meta.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Per-arg projection emitted by the build transformer for Tier-2 input capture.
+ *
+ * The projection turns a raw argument into a trace-safe payload, derived at
+ * compile time from the parameter's type and the `.traceSafe()` markings in
+ * the `pipe.define()` registry. The runtime then runs the projected value
+ * through the bounded serializer before staging it on
+ * `trace_step.captured_inputs`.
+ *
+ * The projection may return any JSON-shaped value, including `undefined` for
+ * "this arg has no safe fields to capture" (fail-closed default).
+ */
+export type CaptureProjection = (arg: unknown) => unknown;
+/**
+ * One `@touches Entity:verb` target baked into a step's meta. Mirrors the
+ * `EntityTouch` shape the annotation parser produces — duplicated here so the
+ * runtime has no compile-time dependency on `src/trace/annotation/*` (the
+ * transformer is the only thing that bridges the two).
+ */
+export interface MetaTouch {
+    readonly entity: string;
+    readonly verb: string;
+}
+export interface FlowStepMeta {
+    /** The `path:symbol` flow-graph node id of the documented function. */
+    readonly ref: string;
+    /**
+     * Per-arg capture projections, in parameter order. `null` at a slot means
+     * "no projection — pass the raw arg through to the bounded serializer"
+     * (primitives, or `any`-typed parameters with no registry entry).
+     *
+     * Absent entirely means the transformer chose to skip Tier-2 capture for
+     * this step. The runtime stages `capturedInputs: null` and incurs no
+     * per-arg cost.
+     */
+    readonly capture?: ReadonlyArray<CaptureProjection | null>;
+    /**
+     * `@touches Entity:verb` targets declared on this step. Empty / absent means
+     * the step has no audit projection — the write surface emits vanilla DML
+     * (no CTE) and the runtime emits no read-touches `audit_record` row.
+     *
+     * When present, the active step's touches surface through the trace's
+     * `StepBuffer` for the executor's CTE generator (write-touches) and for
+     * `__flowStep`'s step-completion path (read-touches).
+     */
+    readonly touches?: ReadonlyArray<MetaTouch>;
+}
+//# sourceMappingURL=step-meta.d.ts.map

package/dist/trace/runtime/step-meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-meta.d.ts","sourceRoot":"","sources":["../../../src/trace/runtime/step-meta.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAA;AAEzD;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,YAAY;IAC3B,uEAAuE;IACvE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB;;;;;;;;OAQG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAA;IAC1D;;;;;;;;OAQG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,CAAA;CAC5C"}

package/dist/trace/runtime/step-meta.js

@@ -0,0 +1,6 @@
+// The compile-time identity of a flow step. The build transformer (component 5)
+// bakes one of these in as a literal at every wrapped call site — `__flowStep`
+// never computes it. `ref` is the `path:symbol` node id, matching the
+// `@upstream` / `@downstream` targets the annotation grammar produces.
+export {};
+//# sourceMappingURL=step-meta.js.map

package/dist/trace/runtime/step-meta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-meta.js","sourceRoot":"","sources":["../../../src/trace/runtime/step-meta.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,+EAA+E;AAC/E,sEAAsE;AACtE,uEAAuE"}

package/dist/trace/runtime/thenable.d.ts

@@ -0,0 +1,3 @@
+/** True for any thenable — a native `Promise` or a custom PromiseLike. */
+export declare function isThenable(value: unknown): value is PromiseLike<unknown>;
+//# sourceMappingURL=thenable.d.ts.map

package/dist/trace/runtime/thenable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thenable.d.ts","sourceRoot":"","sources":["../../../src/trace/runtime/thenable.ts"],"names":[],"mappings":"AAMA,0EAA0E;AAC1E,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAAC,OAAO,CAAC,CAIxE"}

package/dist/trace/runtime/thenable.js

@@ -0,0 +1,12 @@
+// A flow step's implementation may be synchronous or return a promise, and so
+// may an entry's work. Both `__flowStep` and `finalizeTrace` have to settle the
+// trace exactly when the work does — which means recognising a thenable
+// (anything with a callable `then`, not just a native `Promise`) without
+// awaiting code that never needed to be async.
+/** True for any thenable — a native `Promise` or a custom PromiseLike. */
+export function isThenable(value) {
+    return value !== null
+        && (typeof value === 'object' || typeof value === 'function')
+        && typeof value.then === 'function';
+}
+//# sourceMappingURL=thenable.js.map

package/dist/trace/runtime/thenable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thenable.js","sourceRoot":"","sources":["../../../src/trace/runtime/thenable.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,gFAAgF;AAChF,wEAAwE;AACxE,yEAAyE;AACzE,+CAA+C;AAE/C,0EAA0E;AAC1E,MAAM,UAAU,UAAU,CAAC,KAAc;IACvC,OAAO,KAAK,KAAK,IAAI;WAChB,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,UAAU,CAAC;WAC1D,OAAQ,KAA4B,CAAC,IAAI,KAAK,UAAU,CAAA;AAC/D,CAAC"}

package/dist/trace/runtime/truncate-trace.d.ts

@@ -0,0 +1,5 @@
+import type { Manifold } from '../../core/pipework.js';
+import type { TraceContext } from '../entry/trace-context.js';
+/** Fires Q7 truncation: flushes the buffer and stamps `truncated` on the trace row. */
+export declare function truncateTrace(instance: Manifold, ctx: TraceContext): Promise<void>;
+//# sourceMappingURL=truncate-trace.d.ts.map

package/dist/trace/runtime/truncate-trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"truncate-trace.d.ts","sourceRoot":"","sources":["../../../src/trace/runtime/truncate-trace.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AAMtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAE7D,uFAAuF;AACvF,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA0BlF"}

package/dist/trace/runtime/truncate-trace.js

@@ -0,0 +1,44 @@
+// Q7 truncation. The step cap fired — the trace's longest non-branch path was
+// supposed to be bounded by `structuralMax`, and we just crossed
+// `structuralMax × safetyFactor`. That means the static DAG analysis was wrong
+// (a branch the cardinality check missed) or unannotated recursion slipped
+// validation. Either way it's a bug signal, not a load condition: the cap
+// firing is loud on purpose.
+//
+// The work itself keeps running: `__flowStep` already flips to its
+// off-the-traced-path pass-through, so the rest of the trace costs nothing.
+// Here we finalize the trace as a casualty — flush whatever's buffered so far,
+// stamp `status = 'truncated'` and `truncated_at_seq` on the row, and log loud.
+//
+// `closedAt` is *not* set: the entry hasn't finished yet. When it does,
+// `closeTrace` fills it in and triggers the copy-on-error so the cold row
+// reflects the final state (Q4). The truncation's settle handle is stored on
+// the buffer so `closeTrace` can wait for `truncated_at_seq` to land before it
+// copies.
+import { getBaseLogger } from '../../core/logging/index.js';
+import { eq, and, getTableColumns } from '../../data/query/index.js';
+import { trace } from '../schema/trace.js';
+import { flushSteps } from './flush-steps.js';
+/** Fires Q7 truncation: flushes the buffer and stamps `truncated` on the trace row. */
+export function truncateTrace(instance, ctx) {
+    const truncatedAtSeq = ctx.buffer.truncatedAtSeq;
+    getBaseLogger().error({ traceId: ctx.id, truncatedAtSeq }, 'Trace truncated — step cap exceeded; the flow DAG analysis missed a branch or unannotated recursion');
+    const done = ctx.persisted
+        .then(async () => {
+        const stepFlush = flushSteps(instance, ctx.buffer.drain());
+        const db = instance.pool.getOrCreate(instance.config.database()).drizzle;
+        const table = trace.table();
+        const cols = getTableColumns(table);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Drizzle's update needs the concrete runtime table type
+        const traceUpdate = db.update(table)
+            .set({ status: 'truncated', truncatedAtSeq })
+            .where(and(eq(cols.id, ctx.id), eq(cols.openedDay, ctx.openedDay)));
+        await Promise.all([stepFlush, traceUpdate]);
+    })
+        .catch((err) => {
+        getBaseLogger().error({ err, traceId: ctx.id }, 'Failed to persist trace truncation — the trace row is missing its `truncated` stamp');
+    });
+    ctx.buffer.markTruncationDone(done);
+    return done;
+}
+//# sourceMappingURL=truncate-trace.js.map

package/dist/trace/runtime/truncate-trace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"truncate-trace.js","sourceRoot":"","sources":["../../../src/trace/runtime/truncate-trace.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,iEAAiE;AACjE,+EAA+E;AAC/E,2EAA2E;AAC3E,0EAA0E;AAC1E,6BAA6B;AAC7B,EAAE;AACF,mEAAmE;AACnE,4EAA4E;AAC5E,+EAA+E;AAC/E,gFAAgF;AAChF,EAAE;AACF,wEAAwE;AACxE,0EAA0E;AAC1E,6EAA6E;AAC7E,+EAA+E;AAC/E,UAAU;AAGV,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAA;AAC3D,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAEpE,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAG7C,uFAAuF;AACvF,MAAM,UAAU,aAAa,CAAC,QAAkB,EAAE,GAAiB;IACjE,MAAM,cAAc,GAAG,GAAG,CAAC,MAAM,CAAC,cAAc,CAAA;IAChD,aAAa,EAAE,CAAC,KAAK,CACnB,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,EAAE,cAAc,EAAE,EACnC,qGAAqG,CACtG,CAAA;IACD,MAAM,IAAI,GAAG,GAAG,CAAC,SAAS;SACvB,IAAI,CAAC,KAAK,IAAI,EAAE;QACf,MAAM,SAAS,GAAG,UAAU,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAA;QAC1D,MAAM,EAAE,GAAG,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAA;QACxE,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,EAAE,CAAA;QAC3B,MAAM,IAAI,GAAG,eAAe,CAAC,KAAK,CAAuC,CAAA;QACzE,wHAAwH;QACxH,MAAM,WAAW,GAAI,EAAU,CAAC,MAAM,CAAC,KAAK,CAAC;aAC1C,GAAG,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,cAAc,EAAE,CAAC;aAC5C,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;QACrE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC,CAAA;IAC7C,CAAC,CAAC;SACD,KAAK,CAAC,CAAC,GAAY,EAAE,EAAE;QACtB,aAAa,EAAE,CAAC,KAAK,CACnB,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,EAAE,EACxB,qFAAqF,CACtF,CAAA;IACH,CAAC,CAAC,CAAA;IACJ,GAAG,CAAC,MAAM,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAA;IACnC,OAAO,IAAI,CAAA;AACb,CAAC"}

package/dist/trace/schema/trace-fields.d.ts

@@ -5,7 +5,7 @@ export declare const traceFields: {
     parentId: import("../../data/domain/types.js").FieldDescriptor<import("../../data/domain/brand.js").Branded<string, "TraceId"> | null> & import("../../data/domain/field.js").FieldModifiers<import("../../data/domain/brand.js").Branded<string, "TraceId"> | null>;
     parentStepId: import("../../data/domain/types.js").FieldDescriptor<import("../../data/domain/brand.js").Branded<string, "TraceStepId"> | null> & import("../../data/domain/field.js").FieldModifiers<import("../../data/domain/brand.js").Branded<string, "TraceStepId"> | null>;
     entryKind: import("../../data/domain/types.js").FieldDescriptor<"test" | "http" | "job" | "cron"> & import("../../data/domain/field.js").FieldModifiers<"test" | "http" | "job" | "cron">;
-    status: import("../../data/domain/types.js").FieldDescriptor<"error" | "expired" | "open" | "closed" | "truncated"> & import("../../data/domain/field.js").FieldModifiers<"error" | "expired" | "open" | "closed" | "truncated">;
+    status: import("../../data/domain/types.js").FieldDescriptor<"error" | "open" | "closed" | "truncated" | "expired"> & import("../../data/domain/field.js").FieldModifiers<"error" | "open" | "closed" | "truncated" | "expired">;
     tenantId: import("../../data/domain/types.js").FieldDescriptor<string | null> & import("../../data/domain/field.js").FieldModifiers<string | null>;
     requestId: import("../../data/domain/types.js").FieldDescriptor<string | null> & import("../../data/domain/field.js").FieldModifiers<string | null>;
     sessionId: import("../../data/domain/types.js").FieldDescriptor<string | null> & import("../../data/domain/field.js").FieldModifiers<string | null>;

package/dist/trace/schema/trace-retained.d.ts

@@ -5,7 +5,7 @@ export declare const traceRetained: import("../../data/domain/types.js").Defined
     parentId: import("../../data/domain/types.js").FieldDescriptor<import("../../data/domain/brand.js").Branded<string, "TraceId"> | null> & import("../../data/domain/field.js").FieldModifiers<import("../../data/domain/brand.js").Branded<string, "TraceId"> | null>;
     parentStepId: import("../../data/domain/types.js").FieldDescriptor<import("../../data/domain/brand.js").Branded<string, "TraceStepId"> | null> & import("../../data/domain/field.js").FieldModifiers<import("../../data/domain/brand.js").Branded<string, "TraceStepId"> | null>;
     entryKind: import("../../data/domain/types.js").FieldDescriptor<"test" | "http" | "job" | "cron"> & import("../../data/domain/field.js").FieldModifiers<"test" | "http" | "job" | "cron">;
-    status: import("../../data/domain/types.js").FieldDescriptor<"error" | "expired" | "open" | "closed" | "truncated"> & import("../../data/domain/field.js").FieldModifiers<"error" | "expired" | "open" | "closed" | "truncated">;
+    status: import("../../data/domain/types.js").FieldDescriptor<"error" | "open" | "closed" | "truncated" | "expired"> & import("../../data/domain/field.js").FieldModifiers<"error" | "open" | "closed" | "truncated" | "expired">;
     tenantId: import("../../data/domain/types.js").FieldDescriptor<string | null> & import("../../data/domain/field.js").FieldModifiers<string | null>;
     requestId: import("../../data/domain/types.js").FieldDescriptor<string | null> & import("../../data/domain/field.js").FieldModifiers<string | null>;
     sessionId: import("../../data/domain/types.js").FieldDescriptor<string | null> & import("../../data/domain/field.js").FieldModifiers<string | null>;

package/dist/trace/schema/trace.d.ts

@@ -5,7 +5,7 @@ export declare const trace: import("../../data/domain/types.js").DefinedTable<{
     parentId: import("../../data/domain/types.js").FieldDescriptor<import("../../data/domain/brand.js").Branded<string, "TraceId"> | null> & import("../../data/domain/field.js").FieldModifiers<import("../../data/domain/brand.js").Branded<string, "TraceId"> | null>;
     parentStepId: import("../../data/domain/types.js").FieldDescriptor<import("../../data/domain/brand.js").Branded<string, "TraceStepId"> | null> & import("../../data/domain/field.js").FieldModifiers<import("../../data/domain/brand.js").Branded<string, "TraceStepId"> | null>;
     entryKind: import("../../data/domain/types.js").FieldDescriptor<"test" | "http" | "job" | "cron"> & import("../../data/domain/field.js").FieldModifiers<"test" | "http" | "job" | "cron">;
-    status: import("../../data/domain/types.js").FieldDescriptor<"error" | "expired" | "open" | "closed" | "truncated"> & import("../../data/domain/field.js").FieldModifiers<"error" | "expired" | "open" | "closed" | "truncated">;
+    status: import("../../data/domain/types.js").FieldDescriptor<"error" | "open" | "closed" | "truncated" | "expired"> & import("../../data/domain/field.js").FieldModifiers<"error" | "open" | "closed" | "truncated" | "expired">;
     tenantId: import("../../data/domain/types.js").FieldDescriptor<string | null> & import("../../data/domain/field.js").FieldModifiers<string | null>;
     requestId: import("../../data/domain/types.js").FieldDescriptor<string | null> & import("../../data/domain/field.js").FieldModifiers<string | null>;
     sessionId: import("../../data/domain/types.js").FieldDescriptor<string | null> & import("../../data/domain/field.js").FieldModifiers<string | null>;

package/dist/trace/transformer/build-meta-literal.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+export declare function buildMetaLiteral(factory: ts.NodeFactory, ref: string): ts.ObjectLiteralExpression;
+//# sourceMappingURL=build-meta-literal.d.ts.map

package/dist/trace/transformer/build-meta-literal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-meta-literal.d.ts","sourceRoot":"","sources":["../../../src/trace/transformer/build-meta-literal.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,EAAE,CAAC,uBAAuB,CAKjG"}

package/dist/trace/transformer/build-meta-literal.js

@@ -0,0 +1,8 @@
+// Builds the `FlowStepMeta` object literal the transformer bakes in at every
+// wrap site. The `ref` is the `path:symbol` node id — the same shape the
+// annotation grammar uses for `@upstream` / `@downstream` targets.
+import ts from 'typescript';
+export function buildMetaLiteral(factory, ref) {
+    return factory.createObjectLiteralExpression([factory.createPropertyAssignment('ref', factory.createStringLiteral(ref))], false);
+}
+//# sourceMappingURL=build-meta-literal.js.map

package/dist/trace/transformer/build-meta-literal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-meta-literal.js","sourceRoot":"","sources":["../../../src/trace/transformer/build-meta-literal.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,yEAAyE;AACzE,mEAAmE;AAEnE,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,MAAM,UAAU,gBAAgB,CAAC,OAAuB,EAAE,GAAW;IACnE,OAAO,OAAO,CAAC,6BAA6B,CAC1C,CAAC,OAAO,CAAC,wBAAwB,CAAC,KAAK,EAAE,OAAO,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC,CAAC,EAC3E,KAAK,CACN,CAAA;AACH,CAAC"}

package/dist/trace/transformer/find-flow-step-sites.d.ts

@@ -0,0 +1,24 @@
+import ts from 'typescript';
+import { type FlowStepParseResult } from '@pipework/flow-step-parser';
+export type FlowStepSiteShape = {
+    readonly kind: 'function-declaration';
+    readonly name: string;
+} | {
+    readonly kind: 'variable-declaration';
+    readonly name: string;
+} | {
+    readonly kind: 'rejected';
+    readonly reason: string;
+};
+export interface FlowStepSite {
+    readonly statement: ts.Statement;
+    readonly shape: FlowStepSiteShape;
+    readonly annotation: Exclude<FlowStepParseResult, {
+        kind: 'not-a-flow-step';
+    }>;
+    /** 1-based line where the statement begins. */
+    readonly line: number;
+}
+/** Returns every `@flow_step` site in `sourceFile`, in source order. */
+export declare function findFlowStepSites(sourceFile: ts.SourceFile): readonly FlowStepSite[];
+//# sourceMappingURL=find-flow-step-sites.d.ts.map

package/dist/trace/transformer/find-flow-step-sites.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-flow-step-sites.d.ts","sourceRoot":"","sources":["../../../src/trace/transformer/find-flow-step-sites.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,EAA2B,KAAK,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AAE9F,MAAM,MAAM,iBAAiB,GACzB;IAAE,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChE;IAAE,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChE;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAE1D,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAA;IAChC,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;IACjC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC,mBAAmB,EAAE;QAAE,IAAI,EAAE,iBAAiB,CAAA;KAAE,CAAC,CAAA;IAC9E,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,wEAAwE;AACxE,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,GAAG,SAAS,YAAY,EAAE,CAUpF"}