@remnic/core 9.26.0 → 9.28.0

package/dist/replay/normalizers/claude.d.ts

@@ -1,6 +1,6 @@
 import { ReplayNormalizer } from '../types.js';
 import '../../message-parts/index.js';
-import '../../types-DHBxIF0s.js';
+import '../../types-BA7W-_xy.js';
 import '../../bounded-jsonl-state.js';
 import '../../operator-doctor-types.js';
 import '../../types-continuity.js';

package/dist/replay/normalizers/openclaw.d.ts

@@ -1,6 +1,6 @@
 import { ReplayNormalizer } from '../types.js';
 import '../../message-parts/index.js';
-import '../../types-DHBxIF0s.js';
+import '../../types-BA7W-_xy.js';
 import '../../bounded-jsonl-state.js';
 import '../../operator-doctor-types.js';
 import '../../types-continuity.js';

package/dist/replay/normalizers/shared.d.ts

@@ -1,6 +1,6 @@
 import { ReplayRole } from '../types.js';
 import '../../message-parts/index.js';
-import '../../types-DHBxIF0s.js';
+import '../../types-BA7W-_xy.js';
 import '../../bounded-jsonl-state.js';
 import '../../operator-doctor-types.js';
 import '../../types-continuity.js';

package/dist/replay/runner.d.ts

@@ -1,6 +1,6 @@
 import { ReplaySource, ReplayWarning, ReplayNormalizer, ReplayTurn, ReplayParseOptions } from './types.js';
 import '../message-parts/index.js';
-import '../types-DHBxIF0s.js';
+import '../types-BA7W-_xy.js';
 import '../bounded-jsonl-state.js';
 import '../operator-doctor-types.js';
 import '../types-continuity.js';

package/dist/replay/types.d.ts

@@ -1,5 +1,5 @@
 import { LcmMessagePartInput, MessagePartSourceFormat } from '../message-parts/index.js';
-import { n as SourceConnectorProvenance } from '../types-DHBxIF0s.js';
+import { n as SourceConnectorProvenance } from '../types-BA7W-_xy.js';
 import '../bounded-jsonl-state.js';
 import '../operator-doctor-types.js';
 import '../types-continuity.js';

package/dist/replica-divergence.d.ts

@@ -0,0 +1,279 @@
+import { TokenCapabilities } from './access-token-capabilities.js';
+import { CorpusWatermark } from './corpus-watermark.js';
+import { Y as ReplicaPeersConfig, Z as ReplicaPeerConfig } from './types-BA7W-_xy.js';
+import { ResolveSecretRefFn } from './resolve-auth-token.js';
+import 'node:async_hooks';
+import './message-parts/index.js';
+import './bounded-jsonl-state.js';
+import './operator-doctor-types.js';
+import './types-continuity.js';
+
+/**
+ * Replica divergence detection (issue #2149).
+ *
+ * The corpus-watermark primitive (corpus-watermark.ts, PR #2156) gives each
+ * daemon a cheap, comparable fingerprint of its own memory corpus. This module
+ * is the OTHER half the issue asks for: a daemon configured with peer URLs polls
+ * each peer's authenticated `/health`, compares the peer's watermark set against
+ * the local one PER NAMESPACE, and reports drift (file-count delta, watermark
+ * age delta, digest mismatch) so a months-long silent split-brain becomes a
+ * same-day alert. Detection ONLY — reconciliation is issue #2150.
+ *
+ * Design invariants (from AGENTS.md review-prevention patterns):
+ * - §22 error-result conflation: a peer that times out / refuses / returns
+ *   non-2xx / omits `corpus` is a DISTINCT `unreachable`/`unknown` state, never
+ *   folded into `converged`. A monitor must tell "peer agrees" from "we could
+ *   not ask". The outcome is a discriminated union, not a boolean + empty array.
+ * - §5 state scoping: poll state lives on a per-instance {@link
+ *   ReplicaDivergenceMonitor}, never a bare module global.
+ * - §1/§17/§24/§39 input validation: {@link parseReplicaPeersConfig} rejects
+ *   invalid input (bad url, non-array peers, fractional/non-positive intervals)
+ *   rather than silently defaulting, and coerces string booleans/numbers.
+ * - Peer tokens are secrets: resolved through the SAME `resolveAgentAccessAuthToken`
+ *   indirection as `agentAccessHttp.authToken`, NEVER logged, NEVER echoed into a
+ *   report/health/doctor payload. Peer identity is redacted to `host:port`
+ *   (userinfo/path/query stripped) so a credential embedded in a URL cannot leak.
+ * - Polling never runs inline on the health request path: it reuses the corpus
+ *   stale-while-revalidate / single-flight idiom, serving the last result with
+ *   its timestamp and refreshing in the background.
+ */
+
+/** Per-peer verdict. `unreachable`/`unknown` are NEVER conflated with `converged` (§22). */
+type ReplicaPeerState = "converged" | "diverged" | "unreachable" | "unknown";
+/** Whether a namespace is present on both sides, or only one (its own divergence outcome). */
+type ReplicaNamespacePresence = "both" | "local_only" | "peer_only";
+interface ReplicaNamespaceDelta {
+    namespace: string;
+    presence: ReplicaNamespacePresence;
+    localFileCount: number | null;
+    peerFileCount: number | null;
+    /** |local - peer| when present on both sides, else null. */
+    fileCountDelta: number | null;
+    localNewestWriteAt: string | null;
+    peerNewestWriteAt: string | null;
+    /** |local.newestWriteAt - peer.newestWriteAt| in ms when both are dated, else null. */
+    writeAgeDeltaMs: number | null;
+    /** local.digest === peer.digest when present on both sides, else null. */
+    digestMatch: boolean | null;
+    diverged: boolean;
+    /** Concrete, token-free reasons a namespace diverged (numbers included for the operator). */
+    reasons: string[];
+}
+interface ReplicaPeerReport {
+    /** Redacted `host:port` — never the token, never userinfo/path/query. */
+    peer: string;
+    state: ReplicaPeerState;
+    polledAt: string;
+    /**
+     * Per-namespace deltas. Empty only for a fetch-level `unreachable`/`unknown`
+     * (no comparison ran); a comparison that resolves to `unknown` (an ambiguous
+     * local-only namespace) still carries its deltas.
+     */
+    namespaces: ReplicaNamespaceDelta[];
+    divergedNamespaceCount: number;
+    /** Stable reason code for a non-comparison state (e.g. "timeout", "http_500", "missing_corpus"). */
+    reason?: string;
+}
+/** Local watermark set plus whether every configured namespace was scanned. */
+interface LocalCensus {
+    watermarks: CorpusWatermark[];
+    complete: boolean;
+}
+interface ReplicaDivergenceStatus {
+    enabled: boolean;
+    /**
+     * False when the local corpus census dropped namespaces (a per-namespace scan
+     * failed, or enumeration was still warming). A peer can only be certified
+     * `converged` against a COMPLETE local set — otherwise an unscanned tenant
+     * never enters the comparison and its divergence is invisible. Mirrors the
+     * doctor check's `localCensusComplete` gate (round 4, cursor).
+     */
+    censusComplete?: boolean;
+    /**
+     * True when the feature is enabled with peers configured but no poll has
+     * completed yet (warming, or a persistently failing local-watermark scan).
+     * Distinguishes that in-progress/failed state from the "enabled but no peers
+     * configured" case, which reports `pending: false` with an empty `peers` list
+     * (review round 1).
+     */
+    pending: boolean;
+    /** ISO timestamp of the last completed poll cycle, or null when never polled / disabled. */
+    polledAt: string | null;
+    peers: ReplicaPeerReport[];
+}
+/** Discriminated fetch outcome — the heart of the §22 empty-vs-failed distinction. */
+type PeerFetchOutcome = {
+    readonly kind: "ok";
+    readonly corpus: CorpusWatermark[];
+} | {
+    readonly kind: "unreachable";
+    readonly reason: string;
+} | {
+    readonly kind: "unknown";
+    readonly reason: string;
+};
+/**
+ * Compare a local watermark set against a peer's, per namespace. A namespace on
+ * only one side is its own outcome (never silently skipped):
+ * - `peer_only` is divergence — the peer holds data we lack.
+ * - `local_only` is AMBIGUOUS — a namespace-restricted peer token hides
+ *   namespaces it cannot see (not divergence), but an unrestricted peer that
+ *   genuinely lost the namespace omits it the SAME way, so it cannot be
+ *   certified converged either. It resolves the peer to `unknown` (codex P1).
+ * Digest mismatch flags divergence ONLY at EQUAL total file counts — the same
+ * number of files distributed differently across `<tier>:<category>/<day>`
+ * buckets (a distribution split-brain). The digest hashes per-bucket COUNTS, so
+ * it does NOT catch two replicas whose buckets hold equal counts but different
+ * file contents. Any nonzero count delta already perturbs the digest, so
+ * flagging digest there too would make `maxFileCountDelta` unreachable (codex
+ * P2); within tolerance the count delta is the sole signal.
+ */
+declare function compareReplicaWatermarks(local: readonly CorpusWatermark[], peer: readonly CorpusWatermark[], thresholds: Pick<ReplicaPeersConfig, "maxFileCountDelta" | "maxWatermarkAgeDeltaMs">): {
+    state: "converged" | "diverged" | "unknown";
+    reason?: string;
+    namespaces: ReplicaNamespaceDelta[];
+    divergedNamespaceCount: number;
+};
+type FetchLike = (input: string, init?: {
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    json(): Promise<unknown>;
+    /**
+     * Raw body stream when the transport exposes one (the global `fetch`
+     * Response does). Present so a peer payload can be size-bounded while it is
+     * read; a test double that omits it falls back to `json()`.
+     */
+    body?: unknown;
+}>;
+/**
+ * Cap on a peer's `/health` payload. A configured peer is a trust boundary: a
+ * compromised or malfunctioning one could otherwise stream an unbounded corpus
+ * that `json()` buffers whole, and up to `maxConcurrent` peers are polled at
+ * once, so the exposure multiplies (round 7, codex P2). Generous enough for a
+ * fleet-sized namespace census, small enough that four of them cannot exhaust
+ * the daemon.
+ */
+declare const MAX_PEER_RESPONSE_BYTES: number;
+interface FetchPeerOptions {
+    timeoutMs: number;
+    resolveSecretRef?: ResolveSecretRefFn | null;
+    /** Injectable for tests; defaults to global fetch. */
+    fetchImpl?: FetchLike;
+    /**
+     * Max age (ms) a peer census `computedAt` may reach before the peer is treated
+     * as `unknown`/`peer_census_stale` — a snapshot older than this predates
+     * changes it may not reflect, so it cannot certify convergence (round 6, codex
+     * P1). Reuses the caller's `maxWatermarkAgeDeltaMs`; when unset OR non-positive,
+     * no staleness gate is applied (a 0 bound is the strictest DIVERGENCE mode, not
+     * a 0ms freshness gate — round 6, cursor).
+     */
+    maxCensusAgeMs?: number;
+    /** Wall clock (ms) the staleness gate measures `computedAt` against; defaults to now. */
+    nowMs?: number;
+}
+/** Redact a peer URL to `host:port` — strips userinfo/path/query so a credential in a URL cannot leak. */
+declare function redactPeerUrl(url: string): string;
+/**
+ * Fetch a peer's authenticated `/health` corpus with a bounded timeout, trying
+ * the remnic prefix then the legacy engram prefix. Never throws — every failure
+ * mode maps to a discriminated `unreachable`/`unknown` outcome (§22).
+ */
+declare function fetchPeerWatermarks(peer: ReplicaPeerConfig, options: FetchPeerOptions): Promise<PeerFetchOutcome>;
+interface PollReplicaPeersOptions {
+    config: ReplicaPeersConfig;
+    localWatermarks: readonly CorpusWatermark[];
+    now?: Date;
+    resolveSecretRef?: ResolveSecretRefFn | null;
+    fetchImpl?: FetchLike;
+    maxConcurrent?: number;
+    /** Optional sink for a single deduped warn line per non-converged poll cycle (never contains tokens). */
+    log?: (line: string) => void;
+}
+/**
+ * Poll every configured peer once, compare each against the local watermark set,
+ * and assemble a report. Disabled or peerless → no network at all (returns an
+ * empty report). Never throws: a single peer failure degrades only that peer.
+ */
+declare function pollReplicaPeers(options: PollReplicaPeersOptions): Promise<ReplicaDivergenceStatus>;
+/**
+ * Filter a full report to a presenting token's namespace capabilities, exactly
+ * as the corpus `/health` field is filtered (issue #2156 finding B): a
+ * namespace-restricted token must not learn about namespaces it cannot see. A
+ * peer's reachability state carries no namespace data and is preserved; a
+ * comparison peer's visible state is recomputed from its visible deltas so
+ * divergence in a hidden namespace never leaks as a "diverged" verdict. The
+ * census gate is then re-applied to the FILTERED view: filtering can hide a real
+ * shared divergence and leave a peer_only delta that must not read as a false
+ * split-brain to a restricted caller under an incomplete census (round 6, codex).
+ */
+declare function filterReplicaReportByCaps(report: ReplicaDivergenceStatus, caps: TokenCapabilities | null | undefined): ReplicaDivergenceStatus;
+/**
+ * Overlay the LOCAL-census half of the certification rule onto a whole report:
+ * a peer is `converged` only when the local census scanned EVERY configured
+ * namespace — a dropped local tenant never enters the comparison, so its
+ * divergence would be invisible (round 4). Applied identically by the
+ * background monitor (/health) and `summarizeReplicaDivergence` (doctor) so the
+ * two surfaces cannot disagree about an incomplete census (round 6). Under an
+ * incomplete census every `peer_only` delta is NEUTRALIZED (an incomplete local
+ * scan cannot tell a namespace we genuinely lack from one we merely failed to
+ * read — a false split-brain), so it stops counting as divergence. A peer then
+ * stays `diverged` ONLY if a REAL shared-namespace divergence remains; otherwise
+ * (converged, or peer_only-only) it is `unknown`/`local_census_incomplete`.
+ * unreachable/unknown already carry a truthful state and stand.
+ */
+declare function gateReportByCensus(report: ReplicaDivergenceStatus, censusComplete: boolean): ReplicaDivergenceStatus;
+interface ReplicaDivergenceMonitorOptions {
+    clock?: () => number;
+    resolveSecretRef?: ResolveSecretRefFn | null;
+    fetchImpl?: FetchLike;
+    maxConcurrent?: number;
+    log?: (line: string) => void;
+}
+/**
+ * Instance-scoped (§5) stale-while-revalidate monitor of peer divergence. {@link
+ * getReport} NEVER awaits the poll: it returns the last completed report (stale
+ * allowed, or a never-polled placeholder) and single-flights a background poll
+ * when the entry is missing or older than `pollIntervalMs`. So a `/health` probe
+ * is always O(1) and polling never runs inline on the request path. Disabled or
+ * peerless config short-circuits with zero network work.
+ */
+declare class ReplicaDivergenceMonitor {
+    private cached;
+    /** Earliest clock() at which a failed poll may retry — enforces backoff (round 6). */
+    private nextAttemptAt;
+    private inFlight;
+    private readonly clock;
+    private readonly resolveSecretRef;
+    private readonly fetchImpl;
+    private readonly maxConcurrent;
+    private readonly log;
+    constructor(options?: ReplicaDivergenceMonitorOptions);
+    getReport(input: {
+        /**
+         * Raw `replicaPeers` block. An absent/partial/loosely-typed block (a host
+         * adapter or an older persisted config that bypassed `parseConfig`) resolves
+         * to the documented default — disabled, no peers, no polling — so `/health`
+         * stays answerable instead of throwing (issue #2155 read-boundary pattern).
+         */
+        config: ReplicaPeersConfig | undefined;
+        /** Fresh local watermark set for comparison; invoked only during a background refresh. */
+        computeLocalWatermarks: () => Promise<LocalCensus>;
+        caps?: TokenCapabilities | null;
+        /**
+         * Completeness of the census THIS request is presenting alongside the
+         * report. A cached poll was gated by the census that existed when it ran,
+         * so a since-degraded scan could ship `converged` peers next to an
+         * incomplete corpus (round 9, cursor). Gating on the way out keeps the one
+         * response self-consistent without poisoning the shared cache.
+         */
+        localCensusComplete?: boolean;
+    }): ReplicaDivergenceStatus;
+    private refresh;
+    /** Await any in-flight background poll (deterministic tests / shutdown). */
+    whenIdle(): Promise<void>;
+}
+
+export { type FetchLike, type FetchPeerOptions, type LocalCensus, MAX_PEER_RESPONSE_BYTES, type PeerFetchOutcome, type PollReplicaPeersOptions, ReplicaDivergenceMonitor, type ReplicaDivergenceMonitorOptions, type ReplicaDivergenceStatus, type ReplicaNamespaceDelta, type ReplicaNamespacePresence, type ReplicaPeerReport, type ReplicaPeerState, compareReplicaWatermarks, fetchPeerWatermarks, filterReplicaReportByCaps, gateReportByCensus, pollReplicaPeers, redactPeerUrl };

package/dist/replica-divergence.js

@@ -0,0 +1,28 @@
+import {
+  MAX_PEER_RESPONSE_BYTES,
+  ReplicaDivergenceMonitor,
+  compareReplicaWatermarks,
+  fetchPeerWatermarks,
+  filterReplicaReportByCaps,
+  gateReportByCensus,
+  pollReplicaPeers,
+  redactPeerUrl
+} from "./chunk-CVILPI77.js";
+import "./chunk-WNIUPHWV.js";
+import "./chunk-IJ6WHMFB.js";
+import "./chunk-PQVCH2AE.js";
+import "./chunk-MZWSOLMT.js";
+import "./chunk-2Z24E5W2.js";
+import "./chunk-3WCASNQZ.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  MAX_PEER_RESPONSE_BYTES,
+  ReplicaDivergenceMonitor,
+  compareReplicaWatermarks,
+  fetchPeerWatermarks,
+  filterReplicaReportByCaps,
+  gateReportByCensus,
+  pollReplicaPeers,
+  redactPeerUrl
+};
+//# sourceMappingURL=replica-divergence.js.map

package/dist/replica-divergence.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/replica-peers-config.d.ts

@@ -0,0 +1,5 @@
+export { Z as ReplicaPeerConfig, Y as ReplicaPeersConfig, c7 as parseReplicaPeersConfig, c8 as resolveReplicaPeersConfig } from './types-BA7W-_xy.js';
+import './message-parts/index.js';
+import './bounded-jsonl-state.js';
+import './operator-doctor-types.js';
+import './types-continuity.js';

package/dist/replica-peers-config.js

@@ -0,0 +1,13 @@
+import {
+  parseReplicaPeersConfig,
+  resolveReplicaPeersConfig
+} from "./chunk-WNIUPHWV.js";
+import "./chunk-IJ6WHMFB.js";
+import "./chunk-PQVCH2AE.js";
+import "./chunk-3WCASNQZ.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  parseReplicaPeersConfig,
+  resolveReplicaPeersConfig
+};
+//# sourceMappingURL=replica-peers-config.js.map

package/dist/replica-peers-config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/resolve-auth-token.d.ts

@@ -1,4 +1,4 @@
-import { a7 as SecretRef, a8 as AgentAccessAuthToken } from './types-DHBxIF0s.js';
+import { s as SecretRef, t as AgentAccessAuthToken } from './types-BA7W-_xy.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';
@@ -51,5 +51,24 @@ declare function resolveAgentAccessAuthToken(value: AgentAccessAuthToken | undef
 declare function isAgentAccessSecretRef(value: unknown): value is SecretRef;
 /** Test/operations hook: drop the cache and force resolver rediscovery. */
 declare function clearAuthTokenSecretCache(): void;
+/**
+ * Resolve a host SecretRef resolver, preferring an explicitly supplied one over
+ * the lazy loader.
+ *
+ * Shared by every CLI command that authenticates with a SecretRef — `access
+ * serve` and `doctor` (replica peer tokens, issue #2149) — so the two cannot
+ * drift. Structurally typed rather than importing the CLI's options type, which
+ * would invert the dependency.
+ */
+declare function loadHostSecretRefResolver(options: {
+    resolveSecretRef?: ResolveSecretRefFn | null;
+    loadResolveSecretRef?: () => Promise<ResolveSecretRefFn | null | undefined> | ResolveSecretRefFn | null | undefined;
+}): Promise<ResolveSecretRefFn | null | undefined>;
+/**
+ * Adapt a host's lazily-loaded SecretRef resolver into the eager
+ * `ResolveSecretRefFn` that `EngramAccessService` expects, so replica peer
+ * tokens resolve at poll time (issue #2149).
+ */
+declare function hostSecretRefResolver(options: Parameters<typeof loadHostSecretRefResolver>[0]): ResolveSecretRefFn;
 
-export { type ResolveSecretRefFn, clearAuthTokenSecretCache, isAgentAccessSecretRef, resolveAgentAccessAuthToken };
+export { type ResolveSecretRefFn, clearAuthTokenSecretCache, hostSecretRefResolver, isAgentAccessSecretRef, loadHostSecretRefResolver, resolveAgentAccessAuthToken };

package/dist/resolve-auth-token.js

@@ -1,12 +1,16 @@
 import {
   clearAuthTokenSecretCache,
+  hostSecretRefResolver,
   isAgentAccessSecretRef,
+  loadHostSecretRefResolver,
   resolveAgentAccessAuthToken
-} from "./chunk-TGQ2NTWH.js";
+} from "./chunk-IJ6WHMFB.js";
 import "./chunk-PZ5AY32C.js";
 export {
   clearAuthTokenSecretCache,
+  hostSecretRefResolver,
   isAgentAccessSecretRef,
+  loadHostSecretRefResolver,
   resolveAgentAccessAuthToken
 };
 //# sourceMappingURL=resolve-auth-token.js.map

package/dist/resume-bundles.js

@@ -4,12 +4,12 @@ import {
   recordResumeBundle,
   resolveResumeBundleDir,
   validateResumeBundle
-} from "./chunk-LLISELSY.js";
+} from "./chunk-TBMRQZDY.js";
 import "./chunk-ZRWB5D4H.js";
 import "./chunk-HYQJQGD3.js";
 import "./chunk-KFY3SGN7.js";
 import "./chunk-LMDRGRJ2.js";
-import "./chunk-GJJBPI6I.js";
+import "./chunk-FOCEI3TN.js";
 import "./chunk-NDAH7BJ5.js";
 import "./chunk-7RAJ3GXO.js";
 import "./chunk-Z5LAYHGJ.js";
@@ -22,10 +22,12 @@ import "./chunk-KFZY2OFH.js";
 import "./chunk-S4DDLTPX.js";
 import "./chunk-6HMYUWXR.js";
 import "./chunk-P32IDSHD.js";
+import "./chunk-WNIUPHWV.js";
+import "./chunk-IJ6WHMFB.js";
 import "./chunk-443XCR34.js";
 import "./chunk-5I4M26Q7.js";
+import "./chunk-ZIKENA2C.js";
 import "./chunk-5GKPFL3S.js";
-import "./chunk-4DJQYKMN.js";
 import "./chunk-PQVCH2AE.js";
 import "./chunk-EYIEWJNI.js";
 import "./chunk-JUC24CTX.js";

package/dist/retrieval-agents.d.ts

@@ -1,5 +1,5 @@
-import { Q as QmdSearchResult } from './types-DHBxIF0s.js';
-import { Q as QmdClient } from './qmd-3ILJkC70.js';
+import { Q as QmdSearchResult } from './types-BA7W-_xy.js';
+import { Q as QmdClient } from './qmd-CLWDsbYR.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';

package/dist/retrieval-tiers.d.ts

@@ -1,4 +1,4 @@
-import { au as RetrievalTier } from './types-DHBxIF0s.js';
+import { aw as RetrievalTier } from './types-BA7W-_xy.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';

package/dist/routing/engine.d.ts

@@ -1,4 +1,4 @@
-import { t as MemoryCategory } from '../types-DHBxIF0s.js';
+import { v as MemoryCategory } from '../types-BA7W-_xy.js';
 import '../message-parts/index.js';
 import '../bounded-jsonl-state.js';
 import '../operator-doctor-types.js';

package/dist/routing/store.d.ts

@@ -1,5 +1,5 @@
 import { RoutingEngineOptions, RouteRule } from './engine.js';
-import '../types-DHBxIF0s.js';
+import '../types-BA7W-_xy.js';
 import '../message-parts/index.js';
 import '../bounded-jsonl-state.js';
 import '../operator-doctor-types.js';

package/dist/salvage-envelope.d.ts

@@ -1,5 +1,5 @@
 import { MemoryWriteInput, WriteContext, SealedMemoryEnvelope } from './write-envelope.js';
-import './types-DHBxIF0s.js';
+import './types-BA7W-_xy.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';