@graphrefly/graphrefly 0.33.0 → 0.35.0

package/dist/{index--BTb6HUO.d.ts → index-C40wA8zt.d.ts}

@@ -1,10 +1,11 @@
-import { a as Node } from './node-8qx0kgYt.js';
-import { T as TopicGraph, M as MessagingHubGraph } from './index-Bi4ZP6Hc.js';
-import { L as LLMAdapter } from './types-B2LfBvNc.js';
-import { E as Evaluator, D as DatasetItem, a as EvalResult$1, R as RefineStrategy, b as RefineLoopOptions, c as RefineStatus } from './index-BUtCR0k6.js';
-import { G as Graph, s as GraphProfileResult, r as GraphProfileOptions } from './graph-BROUZPG9.js';
-import { G as GateController } from './index-HvJ90_tX.js';
-import { J as JobQueueGraph } from './index-Dtpr2FIB.js';
+import { NodeInput } from './extra/sources.js';
+import { a as Node } from './node-fSc-hCv8.js';
+import { L as LLMAdapter } from './types-CidcBDuk.js';
+import { T as TopicGraph, M as MessagingHubGraph } from './index-C9xF16gc.js';
+import { E as Evaluator, D as DatasetItem, a as EvalResult$1, R as RefineStrategy, b as RefineLoopOptions, c as RefineStatus } from './index-BF-ssbJB.js';
+import { G as Graph, s as GraphProfileResult, r as GraphProfileOptions } from './graph-Cv-8x0ZI.js';
+import { G as GateController } from './pipeline-graph-HOTU4UG0.js';
+import { J as JobQueueGraph } from './index-CAIhFfws.js';
 
 /**
  * Strategy model and priority scoring (roadmap §9.0).
@@ -349,6 +350,226 @@ interface HarnessLoopOptions<A = unknown> {
     retainedLimit?: number;
 }
 
+/**
+ * actuatorExecutor — bridge a side-effecting actuator into the harness EXECUTE slot.
+ *
+ * `refineExecutor` covers the artifact-typed case (refine a candidate
+ * `T` against an evaluator); `actuatorExecutor` covers the side-effecting
+ * case (write a catalog entry, mutate a template registry, edit a doc on
+ * disk). The user's `apply` callback owns the side effect; the executor
+ * wraps it in the per-item lifecycle that makes the four
+ * {@link HarnessExecutor} contract rules structurally unreachable:
+ *
+ *  1. **One DATA per actuation.** The inner producer captures the first
+ *     DATA from the bridged `apply` result, emits a single
+ *     `ExecuteOutput<R>` carrying the actuation record as `artifact`, and
+ *     completes. Subsequent inner DATAs are ignored.
+ *  2. **Cancel-on-supersede.** A new triaged item supersedes via
+ *     `switchMap`; the prior producer's cleanup fires `ac.abort()`, which
+ *     propagates into `apply`'s `signal` (and through `fromAny`'s
+ *     internal cancellation hooks) so signal-aware actuators stop
+ *     in-flight work instead of double-writing.
+ *  3. **Item via deps, not closure mirror.** The triaged item is captured
+ *     in the `switchMap` callback's lexical scope, not mirrored to a
+ *     side-state node — same shape as `refineExecutor`.
+ *  4. **Fires on result, not input.** The producer emits exactly when
+ *     `apply`'s bridged node settles (or fails). Input-arrival waves
+ *     never produce an `ExecuteOutput`.
+ *
+ * **What `apply` may return.** Anything `fromAny` accepts: a
+ * `Promise<R>`, a `Node<R>`, an `AsyncIterable<R>`, an `Iterable<R>`,
+ * or a synchronous `R`. `Promise<R>` is the typical shape (`writeFile`,
+ * `fetch`, `db.execute`); reactive composition through `Node<R>` is the
+ * escape hatch when the actuator itself wants to surface intermediate
+ * progress before settling.
+ *
+ * **Pairing with `evalVerifier`.** `ExecuteOutput.artifact` is set to
+ * the actuation record; an `evalVerifier<R>` whose `extractArtifact`
+ * returns the record (or a transform of it — typically the post-apply
+ * world state needed by the evaluator) closes the EXECUTE → VERIFY loop
+ * with consistent typing end-to-end.
+ *
+ * @module
+ */
+
+/**
+ * What an actuator's `apply` may return. Mirrors `NodeInput<R>` plus a
+ * raw `R` for synchronous side effects, so callers can write the most
+ * direct shape for their case (Promise for async I/O, raw record for
+ * pure in-memory mutation).
+ */
+type ActuatorResult<R> = NodeInput<R>;
+/** Configuration for {@link actuatorExecutor}. */
+interface ActuatorExecutorConfig<R> {
+    /**
+     * Apply the side effect for this triaged item. Receives the abort
+     * signal — actuators that own real I/O should thread `signal` into
+     * `fetch`, `fs.writeFile`, child-process kills, etc. so that
+     * `switchMap` supersede actually cancels in-flight work.
+     *
+     * The first DATA emitted by the bridged result wins; later DATAs are
+     * discarded. ERROR (or a synchronous throw) is mapped via `onError`.
+     */
+    apply: (item: TriagedItem, opts: {
+        signal: AbortSignal;
+    }) => ActuatorResult<R>;
+    /**
+     * Optional gate — when provided and returning `false`, the actuator
+     * is skipped and the executor emits an `ExecuteOutput` with
+     * `outcome: "failure"` and detail from `skipDetail` (default
+     * `"actuator skipped (shouldApply returned false)"`). Use this to
+     * route interventions the actuator can't handle (e.g. `intervention:
+     * "investigate"` items) into the failure path so the verifier sees
+     * them.
+     */
+    shouldApply?: (item: TriagedItem) => boolean;
+    /** Detail string for the skip path. Default: includes intervention name. */
+    skipDetail?: (item: TriagedItem) => string;
+    /**
+     * Map a successfully-applied actuation record into an `ExecuteOutput<R>`.
+     * Default: `outcome: "success"`, `detail` references the intervention
+     * + summary, `artifact: record`.
+     */
+    toOutput?: (record: R, item: TriagedItem) => ExecuteOutput<R>;
+    /**
+     * Map a thrown / ERROR result into an `ExecuteOutput<R>`. Default:
+     * `outcome: "failure"`, `detail` carries the error message,
+     * `artifact: undefined`.
+     */
+    onError?: (err: unknown, item: TriagedItem) => ExecuteOutput<R>;
+    /** Node name prefix for `describe()` introspection. Default `"actuator-executor"`. */
+    name?: string;
+}
+/**
+ * Build a {@link HarnessExecutor} backed by a side-effecting actuator.
+ *
+ * @example File-system actuator that writes a catalog entry and emits the diff.
+ * ```ts
+ * const harness = harnessLoop("repair", {
+ *   adapter,
+ *   executor: actuatorExecutor<CatalogPatch>({
+ *     async apply(item, { signal }) {
+ *       const patch = patchFromItem(item);
+ *       await fs.writeFile(patch.path, patch.contents, { signal });
+ *       return patch;
+ *     },
+ *     shouldApply: (item) => item.intervention === "catalog-fn",
+ *   }),
+ *   verifier: evalVerifier<CatalogPatch>({
+ *     evaluator,
+ *     datasetFor,
+ *     extractArtifact: (exec) => exec.artifact ?? null,
+ *   }),
+ * });
+ * ```
+ */
+declare function actuatorExecutor<R>(config: ActuatorExecutorConfig<R>): HarnessExecutor<R>;
+
+/**
+ * autoSolidify — promote successful VERIFY runs into a durable artifact
+ * (catalog entry, skill, template, doc edit, …).
+ *
+ * Closes the dogfood retrospective loop: when the harness's VERIFY
+ * stage reports `verified: true`, the validated intervention should
+ * become an authoring artifact the next loop run can rely on. This
+ * primitive is the generic substrate — pass a `write` callback that
+ * does the actual promotion (e.g. `overlay.upsertTemplate` for the
+ * dogfood catalog overlay; `fs.writeFile` for a doc edit; `ctx.skill`
+ * for a Hermes-style skill registry).
+ *
+ * @example Wire the catalog overlay as the solidify target.
+ * ```ts
+ * const solidified = autoSolidify({
+ *   verifyResults: harness.verifyResults.latest,
+ *   extract: (vr) => vr.execution.artifact ?? null,
+ *   write: (entry, vr) => overlay.upsertFn(`learned-${vr.item.summary}`, entry),
+ * });
+ * solidified.subscribe(() => {}); // keep alive for log
+ * ```
+ *
+ * **Why a node and not just an effect.** The returned `Node<R>` emits
+ * each promoted artifact, so callers can pipe solidifications through
+ * the standard reactive surface (`describe()`, `observe()`, replay
+ * buffers) instead of side-channel logging. An audit / dashboard that
+ * wants "what was learned this run?" subscribes to the returned node;
+ * the `write` callback owns the durable side effect.
+ *
+ * **Idempotency is the caller's responsibility.** The primitive
+ * promotes every `verified: true` wave that passes the predicate. If
+ * the harness re-verifies the same item (e.g. via reingestion), the
+ * `write` callback is invoked again. Wrap your write fn with a
+ * dedup-by-key guard if your target store would otherwise bloat. The
+ * inner `seen` set inside this factory is intentionally absent — the
+ * harness already retains via topic logs and the user may want
+ * re-promotion semantics that are domain-specific.
+ *
+ * @module
+ */
+
+/**
+ * Configuration for {@link autoSolidify}.
+ *
+ * `R` is the artifact type the upstream EXECUTE stage produced (and
+ * `evalVerifier` carries through `execution.artifact`). `T` is the
+ * promotion shape — what `write` consumes and what the returned node
+ * emits. Often `T = R`, but they diverge when the actuator's raw
+ * artifact needs a transform before storing (e.g. wrap a `CatalogPatch`
+ * into a `CatalogEntry` with effectiveness metadata).
+ */
+interface AutoSolidifyConfig<R, T = R> {
+    /** Reactive verify-result stream. Typically `harness.verifyResults.latest`. */
+    verifyResults: Node<VerifyResult<R> | null>;
+    /**
+     * Pull the value-to-promote out of a verified VerifyResult.
+     * Default: `(vr) => vr.execution.artifact as T | null`. Return `null`
+     * to skip a particular VerifyResult even when `verified: true` (e.g.
+     * an LLM-default executor produces no artifact and there's nothing to
+     * solidify).
+     */
+    extract?: (vr: VerifyResult<R>) => T | null;
+    /**
+     * Optional gate beyond `verified === true`. When provided, the
+     * primitive only promotes when this returns `true`. Default: pass
+     * everything verified.
+     *
+     * Useful predicates:
+     *  - `(vr) => vr.item.intervention === "catalog-fn"` — only catalog work.
+     *  - `(vr) => (vr.findings ?? []).every(f => !/regression/i.test(f))` —
+     *    skip even-passes that mention regressions.
+     */
+    predicate?: (vr: VerifyResult<R>) => boolean;
+    /**
+     * Promote — usually a side effect (write to overlay, fs, KG, etc.).
+     * Receives the extracted artifact AND the originating VerifyResult so
+     * the writer can use any context it needs (item summary, eval task
+     * IDs, finding text, …) when shaping the durable record.
+     */
+    write: (artifact: T, vr: VerifyResult<R>) => void;
+    /** Node name for `describe()` introspection. Default `"auto-solidify"`. */
+    name?: string;
+}
+/**
+ * Build a `Node<T>` that subscribes to `verifyResults`, filters to
+ * verified passes that produced an extractable artifact, runs `write`,
+ * and emits the artifact. Use the returned node as a subscription
+ * point for audit / dashboard / log pipelines.
+ *
+ * **Terminal-on-error semantics.** A throw from `predicate`, `extract`,
+ * or `write` surfaces as `[[ERROR]]` on the returned node and
+ * **terminates** it — the upstream subscription tears down and no
+ * further DATA is emitted. This matches the spec's terminal-frame
+ * contract for ERROR. If you want the solidify node to stay live
+ * across user-callback throws, wrap your callbacks with try/catch
+ * internally and emit a sentinel value or no-op on failure. A future
+ * non-terminal `errors: Node<unknown>` companion may surface failures
+ * without terminating the success stream — flagged as a follow-up.
+ *
+ * @returns A `Node<T>` that emits one DATA per promoted artifact.
+ *   Stays live as long as `verifyResults` is live AND no user callback
+ *   has thrown.
+ */
+declare function autoSolidify<R, T = R>(config: AutoSolidifyConfig<R, T>): Node<T>;
+
 /**
  * Harness bridge factories (roadmap §9.0).
  *
@@ -759,6 +980,26 @@ declare class HarnessGraph<A = unknown> extends Graph {
     readonly jobs: ReadonlyMap<QueueRoute, JobQueueGraph<TriagedItem>>;
     /** Per-route gate controllers (only for gated queues). */
     readonly gates: ReadonlyMap<QueueRoute, GateController<TriagedItem>>;
+    /**
+     * Per-route queue topics — typed accessor for the four
+     * {@link QUEUE_NAMES} entries (`auto-fix`, `needs-decision`,
+     * `investigation`, `backlog`). Mirrors the `gates` / `jobs` map
+     * shape so callers can iterate `[route, topic]` pairs without
+     * hand-rolling `harness.queues.topicNames()` + meta-topic exclusion.
+     *
+     * Excludes the meta topics that share the hub:
+     * `intake` (use {@link intake}), `verify-results` (use
+     * {@link verifyResults}), `retry` (use {@link retry}), `__unrouted`
+     * (use {@link unrouted}), and the internal `triage-output` fan-in.
+     *
+     * **Why this exists.** `for (const [, topic] of harness.queues)`
+     * appears to iterate via `Graph[Symbol.iterator]`, but that yields
+     * locally-registered nodes only — and `MessagingHubGraph` mounts
+     * topics as child graphs rather than registering them locally, so
+     * the loop yields nothing. This map gives a typed, working
+     * iteration path.
+     */
+    readonly queueTopics: ReadonlyMap<QueueRoute, TopicGraph<TriagedItem>>;
     /** Strategy model bundle — record outcomes, lookup effectiveness. */
     readonly strategy: StrategyModelBundle;
     /** Global retry count across all items (circuit breaker). Reactive — subscribable. */
@@ -773,7 +1014,7 @@ declare class HarnessGraph<A = unknown> extends Graph {
      * in to priority scoring.
      */
     readonly priorityScores?: ReadonlyMap<QueueRoute, Node<number>>;
-    constructor(name: string, queues: MessagingHubGraph, jobs: Map<QueueRoute, JobQueueGraph<TriagedItem>>, gates: Map<QueueRoute, GateController<TriagedItem>>, strategy: StrategyModelBundle, totalRetries: Node<number>, totalReingestions: Node<number>, priorityScores?: Map<QueueRoute, Node<number>>);
+    constructor(name: string, queues: MessagingHubGraph, queueTopics: Map<QueueRoute, TopicGraph<TriagedItem>>, jobs: Map<QueueRoute, JobQueueGraph<TriagedItem>>, gates: Map<QueueRoute, GateController<TriagedItem>>, strategy: StrategyModelBundle, totalRetries: Node<number>, totalReingestions: Node<number>, priorityScores?: Map<QueueRoute, Node<number>>);
     /** Intake topic — publish items here to enter the loop. */
     get intake(): TopicGraph<IntakeItem>;
     /** Verify results topic — subscribe to see verification outcomes. */
@@ -1011,6 +1252,9 @@ declare function harnessTrace(harness: HarnessGraph, opts?: HarnessTraceOptions)
  * @module
  */
 
+type index_ActuatorExecutorConfig<R> = ActuatorExecutorConfig<R>;
+type index_ActuatorResult<R> = ActuatorResult<R>;
+type index_AutoSolidifyConfig<R, T = R> = AutoSolidifyConfig<R, T>;
 type index_CodeChange = CodeChange;
 type index_CodeChangeBridgeOptions = CodeChangeBridgeOptions;
 declare const index_DEFAULT_DECAY_RATE: typeof DEFAULT_DECAY_RATE;
@@ -1070,7 +1314,9 @@ type index_TriagedItem = TriagedItem;
 type index_VerifyOutput = VerifyOutput;
 type index_VerifyPromptFn<A = unknown> = VerifyPromptFn<A>;
 type index_VerifyResult<A = unknown> = VerifyResult<A>;
+declare const index_actuatorExecutor: typeof actuatorExecutor;
 declare const index_affectedTaskFilter: typeof affectedTaskFilter;
+declare const index_autoSolidify: typeof autoSolidify;
 declare const index_beforeAfterCompare: typeof beforeAfterCompare;
 declare const index_codeChangeBridge: typeof codeChangeBridge;
 declare const index_createIntakeBridge: typeof createIntakeBridge;
@@ -1091,7 +1337,7 @@ declare const index_resolvePromptFn: typeof resolvePromptFn;
 declare const index_strategyKey: typeof strategyKey;
 declare const index_strategyModel: typeof strategyModel;
 declare namespace index {
-  export { type index_CodeChange as CodeChange, type index_CodeChangeBridgeOptions as CodeChangeBridgeOptions, index_DEFAULT_DECAY_RATE as DEFAULT_DECAY_RATE, index_DEFAULT_EXECUTE_PROMPT as DEFAULT_EXECUTE_PROMPT, index_DEFAULT_QUEUE_CONFIGS as DEFAULT_QUEUE_CONFIGS, index_DEFAULT_SEVERITY_WEIGHTS as DEFAULT_SEVERITY_WEIGHTS, index_DEFAULT_TRIAGE_PROMPT as DEFAULT_TRIAGE_PROMPT, index_DEFAULT_VERIFY_PROMPT as DEFAULT_VERIFY_PROMPT, type index_ErrorClass as ErrorClass, type index_ErrorClassifier as ErrorClassifier, type index_EvalDelta as EvalDelta, type index_EvalIntakeBridgeOptions as EvalIntakeBridgeOptions, type index_EvalJudgeScore as EvalJudgeScore, type index_EvalResult as EvalResult, type index_EvalTaskDelta as EvalTaskDelta, type index_EvalTaskResult as EvalTaskResult, type index_EvalVerifierConfig as EvalVerifierConfig, type index_EvalVerifierSummary as EvalVerifierSummary, type index_ExecuteOutput as ExecuteOutput, type index_ExecutePromptFn as ExecutePromptFn, type index_ExecutionResult as ExecutionResult, type index_HarnessEvalPairConfig as HarnessEvalPairConfig, type index_HarnessExecutor as HarnessExecutor, index_HarnessGraph as HarnessGraph, type index_HarnessLoopOptions as HarnessLoopOptions, type index_HarnessProfileResult as HarnessProfileResult, type index_HarnessTraceHandle as HarnessTraceHandle, type index_HarnessTraceOptions as HarnessTraceOptions, type index_HarnessVerifier as HarnessVerifier, type index_IntakeBridgeOptions as IntakeBridgeOptions, type index_IntakeItem as IntakeItem, type index_IntakeSource as IntakeSource, type index_Intervention as Intervention, type index_KnownIntakeSource as KnownIntakeSource, type index_LintError as LintError, type index_NotifyEffectOptions as NotifyEffectOptions, type index_NotifyTransport as NotifyTransport, type index_PrioritySignals as PrioritySignals, index_QUEUE_NAMES as QUEUE_NAMES, type index_QueueConfig as QueueConfig, type index_QueueRoute as QueueRoute, type index_RefineExecutorConfig as RefineExecutorConfig, type index_RefineExecutorResult as RefineExecutorResult, type index_RootCause as RootCause, type index_Severity as Severity, type index_StrategyEntry as StrategyEntry, type index_StrategyKey as StrategyKey, type index_StrategyModelBundle as StrategyModelBundle, type index_StrategySnapshot as StrategySnapshot, type index_TestFailure as TestFailure, type index_TraceDetail as TraceDetail, type index_TraceEvent as TraceEvent, type index_TraceEventType as TraceEventType, type index_TriagePromptFn as TriagePromptFn, type index_TriagedItem as TriagedItem, type index_VerifyOutput as VerifyOutput, type index_VerifyPromptFn as VerifyPromptFn, type index_VerifyResult as VerifyResult, index_affectedTaskFilter as affectedTaskFilter, index_beforeAfterCompare as beforeAfterCompare, index_codeChangeBridge as codeChangeBridge, index_createIntakeBridge as createIntakeBridge, index_defaultErrorClassifier as defaultErrorClassifier, index_defaultLlmExecutor as defaultLlmExecutor, index_defaultLlmVerifier as defaultLlmVerifier, index_evalIntakeBridge as evalIntakeBridge, index_evalSource as evalSource, index_evalVerifier as evalVerifier, index_harnessEvalPair as harnessEvalPair, index_harnessLoop as harnessLoop, index_harnessProfile as harnessProfile, index_harnessTrace as harnessTrace, index_notifyEffect as notifyEffect, index_priorityScore as priorityScore, index_refineExecutor as refineExecutor, index_resolvePromptFn as resolvePromptFn, index_strategyKey as strategyKey, index_strategyModel as strategyModel };
+  export { type index_ActuatorExecutorConfig as ActuatorExecutorConfig, type index_ActuatorResult as ActuatorResult, type index_AutoSolidifyConfig as AutoSolidifyConfig, type index_CodeChange as CodeChange, type index_CodeChangeBridgeOptions as CodeChangeBridgeOptions, index_DEFAULT_DECAY_RATE as DEFAULT_DECAY_RATE, index_DEFAULT_EXECUTE_PROMPT as DEFAULT_EXECUTE_PROMPT, index_DEFAULT_QUEUE_CONFIGS as DEFAULT_QUEUE_CONFIGS, index_DEFAULT_SEVERITY_WEIGHTS as DEFAULT_SEVERITY_WEIGHTS, index_DEFAULT_TRIAGE_PROMPT as DEFAULT_TRIAGE_PROMPT, index_DEFAULT_VERIFY_PROMPT as DEFAULT_VERIFY_PROMPT, type index_ErrorClass as ErrorClass, type index_ErrorClassifier as ErrorClassifier, type index_EvalDelta as EvalDelta, type index_EvalIntakeBridgeOptions as EvalIntakeBridgeOptions, type index_EvalJudgeScore as EvalJudgeScore, type index_EvalResult as EvalResult, type index_EvalTaskDelta as EvalTaskDelta, type index_EvalTaskResult as EvalTaskResult, type index_EvalVerifierConfig as EvalVerifierConfig, type index_EvalVerifierSummary as EvalVerifierSummary, type index_ExecuteOutput as ExecuteOutput, type index_ExecutePromptFn as ExecutePromptFn, type index_ExecutionResult as ExecutionResult, type index_HarnessEvalPairConfig as HarnessEvalPairConfig, type index_HarnessExecutor as HarnessExecutor, index_HarnessGraph as HarnessGraph, type index_HarnessLoopOptions as HarnessLoopOptions, type index_HarnessProfileResult as HarnessProfileResult, type index_HarnessTraceHandle as HarnessTraceHandle, type index_HarnessTraceOptions as HarnessTraceOptions, type index_HarnessVerifier as HarnessVerifier, type index_IntakeBridgeOptions as IntakeBridgeOptions, type index_IntakeItem as IntakeItem, type index_IntakeSource as IntakeSource, type index_Intervention as Intervention, type index_KnownIntakeSource as KnownIntakeSource, type index_LintError as LintError, type index_NotifyEffectOptions as NotifyEffectOptions, type index_NotifyTransport as NotifyTransport, type index_PrioritySignals as PrioritySignals, index_QUEUE_NAMES as QUEUE_NAMES, type index_QueueConfig as QueueConfig, type index_QueueRoute as QueueRoute, type index_RefineExecutorConfig as RefineExecutorConfig, type index_RefineExecutorResult as RefineExecutorResult, type index_RootCause as RootCause, type index_Severity as Severity, type index_StrategyEntry as StrategyEntry, type index_StrategyKey as StrategyKey, type index_StrategyModelBundle as StrategyModelBundle, type index_StrategySnapshot as StrategySnapshot, type index_TestFailure as TestFailure, type index_TraceDetail as TraceDetail, type index_TraceEvent as TraceEvent, type index_TraceEventType as TraceEventType, type index_TriagePromptFn as TriagePromptFn, type index_TriagedItem as TriagedItem, type index_VerifyOutput as VerifyOutput, type index_VerifyPromptFn as VerifyPromptFn, type index_VerifyResult as VerifyResult, index_actuatorExecutor as actuatorExecutor, index_affectedTaskFilter as affectedTaskFilter, index_autoSolidify as autoSolidify, index_beforeAfterCompare as beforeAfterCompare, index_codeChangeBridge as codeChangeBridge, index_createIntakeBridge as createIntakeBridge, index_defaultErrorClassifier as defaultErrorClassifier, index_defaultLlmExecutor as defaultLlmExecutor, index_defaultLlmVerifier as defaultLlmVerifier, index_evalIntakeBridge as evalIntakeBridge, index_evalSource as evalSource, index_evalVerifier as evalVerifier, index_harnessEvalPair as harnessEvalPair, index_harnessLoop as harnessLoop, index_harnessProfile as harnessProfile, index_harnessTrace as harnessTrace, index_notifyEffect as notifyEffect, index_priorityScore as priorityScore, index_refineExecutor as refineExecutor, index_resolvePromptFn as resolvePromptFn, index_strategyKey as strategyKey, index_strategyModel as strategyModel };
 }
 
-export { type TraceEventType as $, type IntakeItem as A, type IntakeSource as B, type CodeChange as C, DEFAULT_DECAY_RATE as D, type ErrorClass as E, type Intervention as F, type NotifyTransport as G, type HarnessEvalPairConfig as H, type IntakeBridgeOptions as I, type QueueConfig as J, type KnownIntakeSource as K, type LintError as L, type QueueRoute as M, type NotifyEffectOptions as N, type RefineExecutorResult as O, type PrioritySignals as P, QUEUE_NAMES as Q, type RefineExecutorConfig as R, type RootCause as S, type Severity as T, type StrategyEntry as U, type StrategyKey as V, type StrategyModelBundle as W, type StrategySnapshot as X, type TestFailure as Y, type TraceDetail as Z, type TraceEvent as _, type CodeChangeBridgeOptions as a, type TriagePromptFn as a0, type TriagedItem as a1, type VerifyOutput as a2, type VerifyPromptFn as a3, type VerifyResult as a4, affectedTaskFilter as a5, beforeAfterCompare as a6, codeChangeBridge as a7, createIntakeBridge as a8, defaultErrorClassifier as a9, defaultLlmExecutor as aa, defaultLlmVerifier as ab, evalIntakeBridge as ac, evalSource as ad, evalVerifier as ae, harnessEvalPair as af, harnessLoop as ag, harnessProfile as ah, harnessTrace as ai, notifyEffect as aj, priorityScore as ak, refineExecutor as al, resolvePromptFn as am, strategyKey as an, strategyModel as ao, DEFAULT_EXECUTE_PROMPT as b, DEFAULT_QUEUE_CONFIGS as c, DEFAULT_SEVERITY_WEIGHTS as d, DEFAULT_TRIAGE_PROMPT as e, DEFAULT_VERIFY_PROMPT as f, type ErrorClassifier as g, type EvalDelta as h, index as i, type EvalIntakeBridgeOptions as j, type EvalJudgeScore as k, type EvalResult as l, type EvalTaskDelta as m, type EvalTaskResult as n, type EvalVerifierConfig as o, type EvalVerifierSummary as p, type ExecuteOutput as q, type ExecutePromptFn as r, type ExecutionResult as s, type HarnessExecutor as t, HarnessGraph as u, type HarnessLoopOptions as v, type HarnessProfileResult as w, type HarnessTraceHandle as x, type HarnessTraceOptions as y, type HarnessVerifier as z };
+export { type TestFailure as $, type ActuatorExecutorConfig as A, type HarnessTraceOptions as B, type CodeChange as C, DEFAULT_DECAY_RATE as D, type ErrorClass as E, type HarnessVerifier as F, type IntakeItem as G, type HarnessEvalPairConfig as H, type IntakeBridgeOptions as I, type IntakeSource as J, type Intervention as K, type KnownIntakeSource as L, type LintError as M, type NotifyEffectOptions as N, type NotifyTransport as O, type PrioritySignals as P, QUEUE_NAMES as Q, type QueueConfig as R, type QueueRoute as S, type RefineExecutorConfig as T, type RefineExecutorResult as U, type RootCause as V, type Severity as W, type StrategyEntry as X, type StrategyKey as Y, type StrategyModelBundle as Z, type StrategySnapshot as _, type ActuatorResult as a, type TraceDetail as a0, type TraceEvent as a1, type TraceEventType as a2, type TriagePromptFn as a3, type TriagedItem as a4, type VerifyOutput as a5, type VerifyPromptFn as a6, type VerifyResult as a7, actuatorExecutor as a8, affectedTaskFilter as a9, autoSolidify as aa, beforeAfterCompare as ab, codeChangeBridge as ac, createIntakeBridge as ad, defaultErrorClassifier as ae, defaultLlmExecutor as af, defaultLlmVerifier as ag, evalIntakeBridge as ah, evalSource as ai, evalVerifier as aj, harnessEvalPair as ak, harnessLoop as al, harnessProfile as am, harnessTrace as an, notifyEffect as ao, priorityScore as ap, refineExecutor as aq, resolvePromptFn as ar, strategyKey as as, strategyModel as at, type AutoSolidifyConfig as b, type CodeChangeBridgeOptions as c, DEFAULT_EXECUTE_PROMPT as d, DEFAULT_QUEUE_CONFIGS as e, DEFAULT_SEVERITY_WEIGHTS as f, DEFAULT_TRIAGE_PROMPT as g, DEFAULT_VERIFY_PROMPT as h, index as i, type ErrorClassifier as j, type EvalDelta as k, type EvalIntakeBridgeOptions as l, type EvalJudgeScore as m, type EvalResult as n, type EvalTaskDelta as o, type EvalTaskResult as p, type EvalVerifierConfig as q, type EvalVerifierSummary as r, type ExecuteOutput as s, type ExecutePromptFn as t, type ExecutionResult as u, type HarnessExecutor as v, HarnessGraph as w, type HarnessLoopOptions as x, type HarnessProfileResult as y, type HarnessTraceHandle as z };

package/dist/{index-Bi4ZP6Hc.d.ts → index-C9xF16gc.d.ts}

@@ -1,22 +1,11 @@
-import { a as Node } from './node-8qx0kgYt.js';
-import { G as Graph, a as GraphOptions } from './graph-BROUZPG9.js';
-
-/**
- * Messaging patterns (roadmap §4.2).
- *
- * Pulsar-inspired messaging primitives modeled as graph factories:
- * - `topic()` for append-only topic streams with a retained window.
- * - `subscription()` for cursor-based consumers.
- * - `topicBridge()` for autonomous topic-to-topic relay.
- * - `messagingHub()` for a lazy topic registry.
- *
- * Job queue / job flow primitives live in `patterns/job-queue` — they are a
- * distinct domain that happens to share reactive-log / reactive-map
- * infrastructure with topics.
- */
+import { a as Node } from './node-fSc-hCv8.js';
+import { G as Graph, a as GraphOptions } from './graph-Cv-8x0ZI.js';
+import { R as ReactiveLogBundle } from './reactive-log-ByBb8g6A.js';
+import { AppendLogStorageTier } from './extra/storage-tiers.js';
 
 type TopicOptions = {
     graph?: GraphOptions;
+    /** Bounded retention; default 1024 per cross-cutting policy (Audit 2/4). */
     retainedLimit?: number;
 };
 declare class TopicGraph<T> extends Graph {
@@ -42,14 +31,48 @@ declare class TopicGraph<T> extends Graph {
     readonly hasLatest: Node<boolean>;
     constructor(name: string, opts?: TopicOptions);
     publish(value: T): void;
+    /**
+     * Wire one or more append-log storage tiers (Audit 4). Each tier receives
+     * appended events per wave; rollback honors the wave-as-transaction model.
+     *
+     * Named `attachEventStorage` (not `attachStorage`) to avoid colliding with
+     * the inherited {@link Graph.attachSnapshotStorage} which takes the
+     * snapshot-based `StorageTier[]` shape.
+     *
+     * @returns Disposer.
+     */
+    attachEventStorage(tiers: readonly AppendLogStorageTier<T>[]): () => void;
     retained(): readonly T[];
+    /** Internal log bundle — used by TopicBridgeGraph for `attach`. */
+    get _logBundle(): ReactiveLogBundle<T>;
 }
 type SubscriptionOptions = {
     graph?: GraphOptions;
+    /**
+     * Starting cursor position.
+     * @deprecated Use `from` instead.
+     */
     cursor?: number;
+    /**
+     * Starting position for the subscription.
+     * - `"retained"` (default) — cursor starts at 0; consumer sees all retained history.
+     * - `"now"` — cursor starts at current topic length; consumer ignores history.
+     * - `number` — explicit cursor position.
+     */
+    from?: "now" | "retained" | number;
+    /**
+     * When this signal node emits DATA, the subscription auto-advances cursor
+     * to current `available.length`. Useful for "ack everything when X happens"
+     * patterns. The reactive edge `advanceOn → cursor` is visible in `explain()`.
+     */
+    advanceOn?: Node<unknown>;
+};
+/** Result of {@link SubscriptionGraph.pullAndAck}. */
+type PullAndAckResult<T> = {
+    items: readonly T[];
+    cursor: number;
 };
 declare class SubscriptionGraph<T> extends Graph {
-    readonly source: Node<readonly T[]>;
     readonly cursor: Node<number>;
     readonly available: Node<readonly T[]>;
     /**
@@ -61,24 +84,74 @@ declare class SubscriptionGraph<T> extends Graph {
      * still wires the data dependency across graph boundaries. D1(e).
      */
     readonly topic: TopicGraph<T>;
+    private _disposed;
     constructor(name: string, topicGraph: TopicGraph<T>, opts?: SubscriptionOptions);
     ack(count?: number): number;
-    pull(limit?: number, opts?: {
-        ack?: boolean;
-    }): readonly T[];
+    pull(limit?: number): readonly T[];
+    /**
+     * Atomic pull-and-acknowledge. Returns `{ items, cursor }` where `cursor`
+     * is the new cursor position after advancing. Under single-threaded JS the
+     * snapshot and advance are atomic; PY callers use a per-subscription Lock.
+     *
+     * Replaces `pull(limit, { ack: true })`.
+     */
+    pullAndAck(limit?: number): PullAndAckResult<T>;
+    /**
+     * Release internal subscriptions and mark the subscription torn-down.
+     * Subsequent `pull`, `pullAndAck`, `ack` return empty / current cursor.
+     * Emits COMPLETE on `cursor` so derived consumers (e.g. `available`) see
+     * the termination signal. Also drains `addDisposer` callbacks (including
+     * the `keepalive(advancePump)` subscription) so no keepalive leak occurs.
+     */
+    dispose(): void;
 }
 type TopicBridgeOptions<TIn, TOut> = {
     graph?: GraphOptions;
     cursor?: number;
     maxPerPump?: number;
+    /**
+     * Optional transform/filter applied to each item before republishing.
+     *
+     * **At-most-once with silent drop:** when `map` returns `undefined`, the
+     * input is consumed from the source cursor but NOT republished. Filtered
+     * items are not retained for retry. If you need filter-with-retry
+     * semantics, do the filtering in a downstream subscription on the bridged
+     * output rather than in the `map` function.
+     */
     map?: (value: TIn) => TOut | undefined;
 };
 declare class TopicBridgeGraph<TIn, TOut = TIn> extends Graph {
     private readonly _sourceSub;
-    private readonly _target;
     readonly bridgedCount: Node<number>;
+    /**
+     * Emits each mapped batch as DATA — gives downstream observers a reactive
+     * stream of bridged values. Also the link target for `target._log.attach`.
+     */
+    readonly output: Node<readonly TOut[]>;
     constructor(name: string, sourceTopic: TopicGraph<TIn>, targetTopic: TopicGraph<TOut>, opts?: TopicBridgeOptions<TIn, TOut>);
 }
+/**
+ * Private pure data structure managing a named set of {@link TopicGraph}
+ * instances. Extracted from {@link MessagingHubGraph} for separation of
+ * concerns (B.2 Unit 14 lock: D — split into TopicRegistry + facade).
+ *
+ * Reusable if other domain consumers (e.g. cqrs.eventLogs) want a shared
+ * topic registry later.
+ *
+ * @internal
+ */
+declare class TopicRegistry {
+    private readonly _map;
+    /** Reactive monotonic version counter. Advances on topic create/remove. */
+    readonly version: Node<number>;
+    constructor(versionNode: Node<number>);
+    get size(): number;
+    has(name: string): boolean;
+    get<T>(name: string): TopicGraph<T> | undefined;
+    set<T>(name: string, t: TopicGraph<T>): void;
+    delete(name: string): boolean;
+    keys(): IterableIterator<string>;
+}
 type MessagingHubOptions = {
     graph?: GraphOptions;
     /**
@@ -93,6 +166,9 @@ type MessagingHubOptions = {
  * instances with retention + cursor semantics. Topics are created on first
  * access; `removeTopic(name)` unmounts and tears down via {@link Graph.remove}.
  *
+ * Internally delegates to {@link TopicRegistry} for topic map management
+ * (B.2 Unit 14 lock: D facade split).
+ *
  * **Relationship to `pubsub()` in `src/extra/pubsub.ts`:** `pubsub` is a
  * lightweight last-value state hub (no retention, no cursors). `MessagingHubGraph`
  * is the full messaging hub — retained message logs, cursor-based subscriptions,
@@ -101,12 +177,11 @@ type MessagingHubOptions = {
  * @category patterns
  */
 declare class MessagingHubGraph extends Graph {
-    private readonly _topics;
-    private _version;
+    private readonly _registry;
+    /** Reactive monotonic version counter — advances on topic create/remove. */
+    readonly version: Node<number>;
     private readonly _defaultTopicOptions;
     constructor(name: string, opts?: MessagingHubOptions);
-    /** Monotonic counter advancing on topic create/remove. */
-    get version(): number;
     /** Number of topics currently in the hub. */
     get size(): number;
     /** Checks topic existence without creating. */
@@ -181,12 +256,18 @@ declare function messagingHub(name: string, opts?: MessagingHubOptions): Messagi
 declare function subscription<T>(name: string, topicGraph: TopicGraph<T>, opts?: SubscriptionOptions): SubscriptionGraph<T>;
 /**
  * Creates an autonomous cursor-based topic relay graph.
+ *
+ * When `opts.map` is provided, items where `map` returns `undefined` are
+ * consumed from the source cursor but NOT republished (at-most-once with
+ * silent drop). For filter-with-retry semantics, apply the filter in a
+ * downstream subscription on the bridge's `output` node instead.
  */
 declare function topicBridge<TIn, TOut = TIn>(name: string, sourceTopic: TopicGraph<TIn>, targetTopic: TopicGraph<TOut>, opts?: TopicBridgeOptions<TIn, TOut>): TopicBridgeGraph<TIn, TOut>;
 
 type index_MessagingHubGraph = MessagingHubGraph;
 declare const index_MessagingHubGraph: typeof MessagingHubGraph;
 type index_MessagingHubOptions = MessagingHubOptions;
+type index_PullAndAckResult<T> = PullAndAckResult<T>;
 type index_SubscriptionGraph<T> = SubscriptionGraph<T>;
 declare const index_SubscriptionGraph: typeof SubscriptionGraph;
 type index_SubscriptionOptions = SubscriptionOptions;
@@ -196,12 +277,14 @@ type index_TopicBridgeOptions<TIn, TOut> = TopicBridgeOptions<TIn, TOut>;
 type index_TopicGraph<T> = TopicGraph<T>;
 declare const index_TopicGraph: typeof TopicGraph;
 type index_TopicOptions = TopicOptions;
+type index_TopicRegistry = TopicRegistry;
+declare const index_TopicRegistry: typeof TopicRegistry;
 declare const index_messagingHub: typeof messagingHub;
 declare const index_subscription: typeof subscription;
 declare const index_topic: typeof topic;
 declare const index_topicBridge: typeof topicBridge;
 declare namespace index {
-  export { index_MessagingHubGraph as MessagingHubGraph, type index_MessagingHubOptions as MessagingHubOptions, index_SubscriptionGraph as SubscriptionGraph, type index_SubscriptionOptions as SubscriptionOptions, index_TopicBridgeGraph as TopicBridgeGraph, type index_TopicBridgeOptions as TopicBridgeOptions, index_TopicGraph as TopicGraph, type index_TopicOptions as TopicOptions, index_messagingHub as messagingHub, index_subscription as subscription, index_topic as topic, index_topicBridge as topicBridge };
+  export { index_MessagingHubGraph as MessagingHubGraph, type index_MessagingHubOptions as MessagingHubOptions, type index_PullAndAckResult as PullAndAckResult, index_SubscriptionGraph as SubscriptionGraph, type index_SubscriptionOptions as SubscriptionOptions, index_TopicBridgeGraph as TopicBridgeGraph, type index_TopicBridgeOptions as TopicBridgeOptions, index_TopicGraph as TopicGraph, type index_TopicOptions as TopicOptions, index_TopicRegistry as TopicRegistry, index_messagingHub as messagingHub, index_subscription as subscription, index_topic as topic, index_topicBridge as topicBridge };
 }
 
-export { MessagingHubGraph as M, SubscriptionGraph as S, TopicGraph as T, type MessagingHubOptions as a, type SubscriptionOptions as b, TopicBridgeGraph as c, type TopicBridgeOptions as d, type TopicOptions as e, topicBridge as f, index as i, messagingHub as m, subscription as s, topic as t };
+export { MessagingHubGraph as M, type PullAndAckResult as P, SubscriptionGraph as S, TopicGraph as T, type MessagingHubOptions as a, type SubscriptionOptions as b, TopicBridgeGraph as c, type TopicBridgeOptions as d, type TopicOptions as e, TopicRegistry as f, topicBridge as g, index as i, messagingHub as m, subscription as s, topic as t };