@moltzap/client 2026.518.0 → 2026.519.1

package/dist/notification/__tests__/snapshot-semantics.types-check.js

@@ -0,0 +1,62 @@
+/**
+ * Type-canary for AD1 (architect-decision: trust `Stream.runForEach`
+ * cancellation to preserve spec #222 §5.3 OQ-3 snapshot semantics).
+ *
+ * Compile-time assertions only — this file is referenced by `tsc --build`
+ * (via the package's vitest config glob) but has no runtime test bodies.
+ * Any drift in `subscribe` / `subscribeAll` public signatures, or in the
+ * Stream lifecycle contract, surfaces as a TypeScript error here.
+ *
+ * **DO NOT delete this file** without first updating spec #596 AD1 and
+ * the architect plan at issue #604.
+ *
+ * **Architect stub** (Spec B): canaries probe the architect-stubbed
+ * `subscribe` / `subscribeAll` signatures in `../stream.ts`. Impl-staff
+ * preserves the canary shapes and re-targets them at
+ * `MoltZapWsClient.prototype.subscribe` / `.subscribeAll` once the
+ * methods are wired.
+ */
+import { Stream } from "effect";
+import { subscribe, subscribeAll } from "../stream.js";
+// Phantom value-level pin: passing a Canary alias forces tsc to resolve
+// the alias; a `false` resolution fires TS2344 because `false` is not
+// assignable to the `true` constraint.
+function assertCanary() {
+    // intentionally empty: type-level pin
+}
+import { PresenceChangedNotificationDefinition } from "@moltzap/protocol";
+const _canary1bStream = subscribe(_canary1bRegistry, PresenceChangedNotificationDefinition, _canary1bIsOnline);
+// P3 #612 fix: ground Canary #3 in the ACTUAL return type of a real
+// `Stream.runForEach(_subStreamForCanary, _handlerForCanary)` call,
+// not a manually-reconstructed `Effect<…, E, R>` inferred from the
+// Stream's own type parameters (which would be a tautology). Calling
+// `runForEach` and capturing the return type forces TypeScript to
+// resolve the overloads using the real Stream value's signature.
+const _ad1Canary3Helper = () => Stream.runForEach(_subStreamForCanary, _handlerForCanary);
+// Phantom value-level call sites: pin each Canary alias as used and let
+// knip/oxlint see the file as fully reachable. tsc never invokes
+// `_ad1Canaries`; the canary alias resolutions happen at type-check
+// time inside the function body.
+function _ad1Canaries() {
+    assertCanary();
+    assertCanary();
+    assertCanary();
+    assertCanary();
+    assertCanary();
+    // Force the runtime-shape value declarations to be used (otherwise
+    // tsc warns even on `declare const`). Also exercises a real call
+    // into Stream.runForEach to keep Canary #3's premise grounded.
+    Stream.runForEach(_subStreamForCanary, _handlerForCanary);
+    _ad1Canary3Helper();
+    // Touch `_canary1bStream` so tsc keeps the canary-call expression
+    // alive (the `Equal<>` assertion + the assignment below force the
+    // overload to resolve at compile time).
+    const _touch1b = _canary1bStream;
+    if (false)
+        _touch1b;
+}
+// Discard return so module-level `_ad1Canaries` is read; an assignment
+// to `_` satisfies the linter without invoking the function.
+const _adhoc_phantom_canary_ref = _ad1Canaries;
+export { _adhoc_phantom_canary_ref };
+//# sourceMappingURL=snapshot-semantics.types-check.js.map

package/dist/notification/__tests__/snapshot-semantics.types-check.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-semantics.types-check.js","sourceRoot":"","sources":["../../../src/notification/__tests__/snapshot-semantics.types-check.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAQhC,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAQvD,wEAAwE;AACxE,sEAAsE;AACtE,uCAAuC;AACvC,SAAS,YAAY;IACnB,sCAAsC;AACxC,CAAC;AA2CD,OAAO,EAAE,qCAAqC,EAAE,MAAM,mBAAmB,CAAC;AAS1E,MAAM,eAAe,GAAG,SAAS,CAC/B,iBAAiB,EACjB,qCAAqC,EACrC,iBAAiB,CAClB,CAAC;AAsCF,oEAAoE;AACpE,oEAAoE;AACpE,mEAAmE;AACnE,qEAAqE;AACrE,kEAAkE;AAClE,iEAAiE;AACjE,MAAM,iBAAiB,GAAG,GAAG,EAAE,CAC7B,MAAM,CAAC,UAAU,CAAC,mBAAmB,EAAE,iBAAiB,CAAC,CAAC;AAe5D,wEAAwE;AACxE,iEAAiE;AACjE,oEAAoE;AACpE,iCAAiC;AACjC,SAAS,YAAY;IACnB,YAAY,EAAmC,CAAC;IAChD,YAAY,EAAsC,CAAC;IACnD,YAAY,EAAmC,CAAC;IAChD,YAAY,EAA6C,CAAC;IAC1D,YAAY,EAA6B,CAAC;IAC1C,mEAAmE;IACnE,iEAAiE;IACjE,+DAA+D;IAC/D,MAAM,CAAC,UAAU,CAAC,mBAAmB,EAAE,iBAAiB,CAAC,CAAC;IAC1D,iBAAiB,EAAE,CAAC;IACpB,kEAAkE;IAClE,kEAAkE;IAClE,wCAAwC;IACxC,MAAM,QAAQ,GAA2B,eAAe,CAAC;IACzD,IAAI,KAAgB;QAAE,QAAQ,CAAC;AACjC,CAAC;AACD,uEAAuE;AACvE,6DAA6D;AAC7D,MAAM,yBAAyB,GAAY,YAAY,CAAC;AACxD,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/notification/errors.d.ts

@@ -0,0 +1,27 @@
+declare const TimeoutError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "TimeoutError";
+} & Readonly<A>;
+export declare class TimeoutError extends TimeoutError_base<{
+    readonly definition: string;
+    readonly durationMs: number;
+}> {
+}
+declare const StreamClosedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "StreamClosedError";
+} & Readonly<A>;
+export declare class StreamClosedError extends StreamClosedError_base<{
+    readonly definition: string;
+}> {
+}
+/**
+ * Union of all notification consumer error tags. Catch sites use
+ * `Effect.catchTags({ TimeoutError: ..., StreamClosedError: ... })` for
+ * exhaustive handling, or accept this union in their typed error channel.
+ *
+ * NOT a class — Effect's `Data.TaggedError` classes do not inherit from
+ * a shared `Data.TaggedError` base in a way that preserves `_tag`
+ * discrimination. The union is the canonical shape.
+ */
+export type NotificationConsumerError = TimeoutError | StreamClosedError;
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/notification/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/notification/errors.ts"],"names":[],"mappings":";;;AAoBA,qBAAa,YAAa,SAAQ,kBAAiC;IACjE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B,CAAC;CAAG;;;;AAEL,qBAAa,iBAAkB,SAAQ,uBAAsC;IAC3E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B,CAAC;CAAG;AAEL;;;;;;;;GAQG;AACH,MAAM,MAAM,yBAAyB,GAAG,YAAY,GAAG,iBAAiB,CAAC"}

package/dist/notification/errors.js

@@ -0,0 +1,24 @@
+/**
+ * Tagged errors for the notification consumption surface (Spec B, #596).
+ *
+ * Per architect-revision r1 (codex review finding #8): `Data.TaggedError`
+ * classes do NOT compose via class inheritance — extending one tagged
+ * class from another produces broken `_tag` discrimination at runtime.
+ * The shared abstraction is therefore a TYPE UNION (`NotificationConsumerError`)
+ * not a base class. Catch sites that want to handle "any notification
+ * consumer error" pattern-match on the union.
+ *
+ * `TimeoutError` carries the timeout duration so callers can log + retry
+ * with sane backoff. `StreamClosedError` fires when the consumer's Stream
+ * completes empty (e.g. the client transitioned to terminal closed state
+ * before a notification arrived).
+ *
+ * **Architect stub** (Spec B). Impl-staff fills any helper combinators
+ * (`isTimeoutError`, mapping helpers) per downstream consumer needs.
+ */
+import { Data } from "effect";
+export class TimeoutError extends Data.TaggedError("TimeoutError") {
+}
+export class StreamClosedError extends Data.TaggedError("StreamClosedError") {
+}
+//# sourceMappingURL=errors.js.map

package/dist/notification/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/notification/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B,MAAM,OAAO,YAAa,SAAQ,IAAI,CAAC,WAAW,CAAC,cAAc,CAG/D;CAAG;AAEL,MAAM,OAAO,iBAAkB,SAAQ,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAEzE;CAAG"}

package/dist/notification/stream.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Stream-returning constructors for `MoltZapWsClient.subscribe` and
+ * `MoltZapWsClient.subscribeAll` (Spec B, #596).
+ *
+ * Architect decision **AD1 — path (a)**: trust `Stream.async` cancellation
+ * to drive registry-stored `unregister` finalizer. The registry's
+ * `dispatch` snapshots `subsRef` at iteration start, so the spec #222
+ * §5.3 OQ-3 snapshot semantic is preserved by Ref atomicity without an
+ * additional per-sub cancelled-flag check (architect plan §3).
+ *
+ * Stream construction uses `Stream.async<DecodedNotification<D>, NotConnectedError>`
+ * with the registry storing typed callback references — NOT `Queue` of
+ * `Take` items combined with `Stream.fromQueue`/`Stream.flattenTake`,
+ * which codex empirically verified is racy under
+ * `Queue.offer(Take.fail); Queue.shutdown` and does not reliably propagate
+ * the typed failure to the consumer (architect plan §3.2, codex r4).
+ *
+ * Stream lifecycle (architect-mandated, spec §"Stream lifecycle contract"):
+ *   1. `subscribe(def)` returns a Stream value. Pure; no I/O, no scope.
+ *   2. Materialization opens the `Stream.async` source: `registry.register`
+ *      runs synchronously, callbacks are installed; consumer pulls suspend
+ *      until `emit.single` fires from dispatch.
+ *   3. Pre-`connect()` consumer pulls suspend inside `Stream.async`'s
+ *      internal queue. No `NotConnectedError` until terminal close.
+ *   4. Reconnect leaves registry callbacks intact; `subsRef` survives
+ *      transient disconnects (preserved invariant).
+ *   5. `MoltZapWsClient.close` invokes `SubscriberRegistry.closeAll`, which
+ *      calls each live `sub.onClose(new NotConnectedError(...))`. Each
+ *      `Stream.async`-backed consumer fails with `NotConnectedError`
+ *      via `emit.fail` deterministically (no Queue/shutdown race).
+ */
+import { Stream } from "effect";
+import { type AnyNotificationDefinition, type DecodedNotification, type NotConnectedError, type NotificationParamsOf } from "@moltzap/protocol";
+import type { SubscriberRegistry } from "../runtime/subscribers.js";
+/**
+ * Typed-payload subscribe. Returns a Stream of `DecodedNotification<D>`
+ * whose error channel is `NotConnectedError` and whose requirement set is
+ * `never` (the registry handle is bound at materialization time inside
+ * `Stream.async`'s register callback, so neither Scope nor any other
+ * requirement leaks to the consumer).
+ *
+ * `refinement` is a typed predicate over the definition's params. When the
+ * type-guard overload form is used, the Stream's payload narrows to
+ * `DecodedNotification<D, R>` via the optional `R` parameter on
+ * `DecodedNotification<D>`.
+ */
+export declare function subscribe<D extends AnyNotificationDefinition>(registry: SubscriberRegistry, definition: D, refinement?: (params: NotificationParamsOf<D>) => boolean): Stream.Stream<DecodedNotification<D>, NotConnectedError, never>;
+export declare function subscribe<D extends AnyNotificationDefinition, R extends NotificationParamsOf<D>>(registry: SubscriberRegistry, definition: D, refinement: (params: NotificationParamsOf<D>) => params is R): Stream.Stream<DecodedNotification<D, R>, NotConnectedError, never>;
+/**
+ * Broad-union escape hatch. The only intended in-tree consumer is
+ * `MoltZapService.connect`, which uses this to fan every inbound
+ * notification through `MoltZapService.handleNotification`. Payload
+ * narrowing is intentionally lost; callers wanting typed payloads use
+ * `subscribe(def, refinement?)`.
+ *
+ * The `subscribeAll` Stream uses a synthetic "match every definition"
+ * filter — implemented by the registry treating a `null` definition
+ * pointer as "match all", but for the Stream API we instead register
+ * one subscription per inbound frame's definition. Simpler: model
+ * "match all" by passing an in-band sentinel.
+ *
+ * Implementation: the registry has no native "match all" subscription
+ * shape (intentional — `subscribe<D>` is per-definition). To preserve
+ * the registry's typed dispatch surface, `subscribeAll` constructs a
+ * Stream that taps the registry via a per-arrival path: registering
+ * once with a sentinel definition would require a registry-level "match
+ * any" capability we deliberately avoid (would complicate the typed
+ * dispatch in subscribers.ts). Instead, the dispatcher feeds every
+ * frame to `subscribeAll`'s emit via a dedicated `subscribeAllRef`
+ * callback list maintained alongside `subsRef`.
+ *
+ * Architect-mandated code shape: per spec Goal #2 / plan §5.3, the
+ * surface returns a Stream value. Implementation passes the literal
+ * `AnyNotificationDefinition` sentinel via the registry's broad-union
+ * channel — see `notification/stream.ts → subscribeAllStream` below
+ * which registers via a new `SubscriberRegistry.registerAll` helper.
+ *
+ * To keep the registry minimal we route `subscribeAll` through a thin
+ * wrapper that the registry exposes as `registerAll(callbacks)` —
+ * identical lifecycle to `register(def, …)` but with no definition
+ * match (the dispatcher hits these callbacks for every inbound frame).
+ */
+export declare function subscribeAll(registry: SubscriberRegistry, refinement?: (notification: DecodedNotification<AnyNotificationDefinition>) => boolean): Stream.Stream<DecodedNotification<AnyNotificationDefinition>, NotConnectedError, never>;
+//# sourceMappingURL=stream.d.ts.map

package/dist/notification/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/notification/stream.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EAC1B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,yBAAyB,EAC3D,QAAQ,EAAE,kBAAkB,EAC5B,UAAU,EAAE,CAAC,EACb,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC,KAAK,OAAO,GACxD,MAAM,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC,CAAC,EAAE,iBAAiB,EAAE,KAAK,CAAC,CAAC;AACnE,wBAAgB,SAAS,CACvB,CAAC,SAAS,yBAAyB,EACnC,CAAC,SAAS,oBAAoB,CAAC,CAAC,CAAC,EAEjC,QAAQ,EAAE,kBAAkB,EAC5B,UAAU,EAAE,CAAC,EACb,UAAU,EAAE,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC,KAAK,MAAM,IAAI,CAAC,GAC3D,MAAM,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,iBAAiB,EAAE,KAAK,CAAC,CAAC;AAkCtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,kBAAkB,EAC5B,UAAU,CAAC,EAAE,CACX,YAAY,EAAE,mBAAmB,CAAC,yBAAyB,CAAC,KACzD,OAAO,GACX,MAAM,CAAC,MAAM,CACd,mBAAmB,CAAC,yBAAyB,CAAC,EAC9C,iBAAiB,EACjB,KAAK,CACN,CAmBA"}

package/dist/notification/stream.js

@@ -0,0 +1,106 @@
+/* eslint-disable jsdoc/text-escaping -- JSDoc references to generic types like `Stream.async<DecodedNotification<D>>` use the natural angle-bracket form (TS source style) inside backtick-fenced code spans; the lint rule's pre-render check fires false positives on these multi-line spans. Matches the precedent in filter-equivalence.test.ts. */
+/**
+ * Stream-returning constructors for `MoltZapWsClient.subscribe` and
+ * `MoltZapWsClient.subscribeAll` (Spec B, #596).
+ *
+ * Architect decision **AD1 — path (a)**: trust `Stream.async` cancellation
+ * to drive registry-stored `unregister` finalizer. The registry's
+ * `dispatch` snapshots `subsRef` at iteration start, so the spec #222
+ * §5.3 OQ-3 snapshot semantic is preserved by Ref atomicity without an
+ * additional per-sub cancelled-flag check (architect plan §3).
+ *
+ * Stream construction uses `Stream.async<DecodedNotification<D>, NotConnectedError>`
+ * with the registry storing typed callback references — NOT `Queue` of
+ * `Take` items combined with `Stream.fromQueue`/`Stream.flattenTake`,
+ * which codex empirically verified is racy under
+ * `Queue.offer(Take.fail); Queue.shutdown` and does not reliably propagate
+ * the typed failure to the consumer (architect plan §3.2, codex r4).
+ *
+ * Stream lifecycle (architect-mandated, spec §"Stream lifecycle contract"):
+ *   1. `subscribe(def)` returns a Stream value. Pure; no I/O, no scope.
+ *   2. Materialization opens the `Stream.async` source: `registry.register`
+ *      runs synchronously, callbacks are installed; consumer pulls suspend
+ *      until `emit.single` fires from dispatch.
+ *   3. Pre-`connect()` consumer pulls suspend inside `Stream.async`'s
+ *      internal queue. No `NotConnectedError` until terminal close.
+ *   4. Reconnect leaves registry callbacks intact; `subsRef` survives
+ *      transient disconnects (preserved invariant).
+ *   5. `MoltZapWsClient.close` invokes `SubscriberRegistry.closeAll`, which
+ *      calls each live `sub.onClose(new NotConnectedError(...))`. Each
+ *      `Stream.async`-backed consumer fails with `NotConnectedError`
+ *      via `emit.fail` deterministically (no Queue/shutdown race).
+ */
+import { Effect, Stream } from "effect";
+import {} from "@moltzap/protocol";
+export function subscribe(registry, definition, refinement) {
+    return Stream.async((emit) => {
+        // Synchronous registration — the registry stores the typed callbacks
+        // and returns an `unregister` Effect that the Stream's runtime will
+        // invoke as the cancellation finalizer. #ignore-sloppy-code[async-keyword]: comment references `Stream.async`, not a function modifier
+        //
+        // `register` is `Effect<SubscriptionHandle, never>`; `runSync` is safe
+        // because the registry mutates an in-memory `Ref` and never yields.
+        const handle = Effect.runSync(registry.register(definition, refinement, {
+            onFrame: (frame) => Effect.sync(() => {
+                emit.single(frame);
+            }),
+            onClose: (cause) => Effect.sync(() => {
+                emit.fail(cause);
+            }),
+        }));
+        // Per P3 issue #613: use `Effect.suspend` to defer running `unregister`
+        // to whenever the Stream's runtime invokes the finalizer Effect. This
+        // is future-proof if `unregister` ever grows yielded effects (e.g.
+        // flushing a queue); the `Effect.sync(() => Effect.runSync(handle.unregister))`
+        // form would force-eager-evaluate as sync.
+        return Effect.suspend(() => handle.unregister);
+    });
+}
+/**
+ * Broad-union escape hatch. The only intended in-tree consumer is
+ * `MoltZapService.connect`, which uses this to fan every inbound
+ * notification through `MoltZapService.handleNotification`. Payload
+ * narrowing is intentionally lost; callers wanting typed payloads use
+ * `subscribe(def, refinement?)`.
+ *
+ * The `subscribeAll` Stream uses a synthetic "match every definition"
+ * filter — implemented by the registry treating a `null` definition
+ * pointer as "match all", but for the Stream API we instead register
+ * one subscription per inbound frame's definition. Simpler: model
+ * "match all" by passing an in-band sentinel.
+ *
+ * Implementation: the registry has no native "match all" subscription
+ * shape (intentional — `subscribe<D>` is per-definition). To preserve
+ * the registry's typed dispatch surface, `subscribeAll` constructs a
+ * Stream that taps the registry via a per-arrival path: registering
+ * once with a sentinel definition would require a registry-level "match
+ * any" capability we deliberately avoid (would complicate the typed
+ * dispatch in subscribers.ts). Instead, the dispatcher feeds every
+ * frame to `subscribeAll`'s emit via a dedicated `subscribeAllRef`
+ * callback list maintained alongside `subsRef`.
+ *
+ * Architect-mandated code shape: per spec Goal #2 / plan §5.3, the
+ * surface returns a Stream value. Implementation passes the literal
+ * `AnyNotificationDefinition` sentinel via the registry's broad-union
+ * channel — see `notification/stream.ts → subscribeAllStream` below
+ * which registers via a new `SubscriberRegistry.registerAll` helper.
+ *
+ * To keep the registry minimal we route `subscribeAll` through a thin
+ * wrapper that the registry exposes as `registerAll(callbacks)` —
+ * identical lifecycle to `register(def, …)` but with no definition
+ * match (the dispatcher hits these callbacks for every inbound frame).
+ */
+export function subscribeAll(registry, refinement) {
+    return Stream.async((emit) => {
+        const handle = Effect.runSync(registry.registerAll(refinement, {
+            onFrame: (frame) => Effect.sync(() => {
+                emit.single(frame);
+            }),
+            onClose: (cause) => Effect.sync(() => {
+                emit.fail(cause);
+            }),
+        }));
+        return Effect.suspend(() => handle.unregister);
+    });
+}
+//# sourceMappingURL=stream.js.map

package/dist/notification/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","sourceRoot":"","sources":["../../src/notification/stream.ts"],"names":[],"mappings":"AAAA,wVAAwV;AAExV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,EAKN,MAAM,mBAAmB,CAAC;AA6B3B,MAAM,UAAU,SAAS,CACvB,QAA4B,EAC5B,UAAa,EACb,UAAyD;IAEzD,OAAO,MAAM,CAAC,KAAK,CAA4C,CAAC,IAAI,EAAE,EAAE;QACtE,qEAAqE;QACrE,oEAAoE;QACpE,uIAAuI;QACvI,EAAE;QACF,uEAAuE;QACvE,oEAAoE;QACpE,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAC3B,QAAQ,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,EAAE;YACxC,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE,CACjB,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE;gBACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACrB,CAAC,CAAC;YACJ,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE,CACjB,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE;gBACf,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACnB,CAAC,CAAC;SACL,CAAC,CACH,CAAC;QACF,wEAAwE;QACxE,sEAAsE;QACtE,mEAAmE;QACnE,gFAAgF;QAChF,2CAA2C;QAC3C,OAAO,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IACjD,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,UAAU,YAAY,CAC1B,QAA4B,EAC5B,UAEY;IAMZ,OAAO,MAAM,CAAC,KAAK,CAGjB,CAAC,IAAI,EAAE,EAAE;QACT,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAC3B,QAAQ,CAAC,WAAW,CAAC,UAAU,EAAE;YAC/B,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE,CACjB,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE;gBACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACrB,CAAC,CAAC;YACJ,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE,CACjB,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE;gBACf,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACnB,CAAC,CAAC;SACL,CAAC,CACH,CAAC;QACF,OAAO,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IACjD,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/runtime/index.d.ts

@@ -1,11 +1,10 @@
 /**
  * @file Local-service IPC primitives and runtime helpers for the client CLI.
  *
- * The public surface is intentionally narrow: command definitions for the
- * local daemon socket and the subscription filter type consumed by status and
- * conformance adapters.
+ * Spec B (#596) deleted the three-field `SubscriptionFilter` re-export — the
+ * notification consumption surface is now Stream-based via
+ * `MoltZapWsClient.subscribe(def, refinement?)`.
  */
 export { LocalServiceCommands } from "./local-service-commands.js";
 export type { LocalServiceCommand } from "./local-service-commands.js";
-export type { SubscriptionFilter } from "./subscribers.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/runtime/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,YAAY,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AACvE,YAAY,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,YAAY,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/runtime/index.js

@@ -1,9 +1,9 @@
 /**
  * @file Local-service IPC primitives and runtime helpers for the client CLI.
  *
- * The public surface is intentionally narrow: command definitions for the
- * local daemon socket and the subscription filter type consumed by status and
- * conformance adapters.
+ * Spec B (#596) deleted the three-field `SubscriptionFilter` re-export — the
+ * notification consumption surface is now Stream-based via
+ * `MoltZapWsClient.subscribe(def, refinement?)`.
  */
 export { LocalServiceCommands } from "./local-service-commands.js";
 //# sourceMappingURL=index.js.map

package/dist/runtime/service-teardown.d.ts

@@ -0,0 +1,5 @@
+import { Effect, Scope } from "effect";
+export declare function composeServiceTeardown(serviceScope: Scope.CloseableScope | null, client: {
+    readonly close: () => Effect.Effect<void, never>;
+} | null): Effect.Effect<void, never>;
+//# sourceMappingURL=service-teardown.d.ts.map

package/dist/runtime/service-teardown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-teardown.d.ts","sourceRoot":"","sources":["../../src/runtime/service-teardown.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAQ,KAAK,EAAE,MAAM,QAAQ,CAAC;AA8B7C,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,KAAK,CAAC,cAAc,GAAG,IAAI,EACzC,MAAM,EAAE;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;CAAE,GAAG,IAAI,GAClE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAQ5B"}

package/dist/runtime/service-teardown.js

@@ -0,0 +1,36 @@
+/* eslint-disable agent-code-guard/no-conditional-chaining -- composeServiceTeardown IS the resolution site for nullable scope+client inputs; the `closeXxxIfPresent` helpers each narrow their one nullable arg to a concrete `Effect`, so by the time `zipRight` runs every value is fully resolved. The rule fires on the parameter declarations (regarding them as "carriers"), but pushing the null-narrowing to every caller of `MoltZapService.close` would duplicate the conditional shape across the package. */
+import { Effect, Exit, Scope } from "effect";
+/**
+ * Build the close-order teardown Effect for `MoltZapService.close`:
+ * close the service-owned scope (which interrupts the
+ * `subscribeAll → Stream.runForEach` fan-out fiber) BEFORE invoking the
+ * ws-client's `close()`. Exposed as a top-level pure helper so the
+ * ordering can be exercised by a regression test without spinning up
+ * the full service. Codex r0 caught the original two-`runFork` race
+ * here; the regression test in `service.test.ts` pins the structural
+ * fix (P2-4 r1 cleanup).
+ *
+ * The chain is single-fork by construction (`Effect.zipRight`): the
+ * ws-client `close()` does not begin until the scope finalizer chain
+ * has completed.
+ */
+function closeScopeIfPresent(serviceScope) {
+    if (serviceScope === null)
+        return Effect.void;
+    return Scope.close(serviceScope, Exit.void);
+}
+function closeClientIfPresent(client) {
+    if (client === null)
+        return Effect.void;
+    return client.close();
+}
+export function composeServiceTeardown(serviceScope, client) {
+    // Resolve each optional input to a concrete Effect via the dedicated
+    // `closeXxxIfPresent` helpers, then sequence with `zipRight`. Single-fork
+    // sequencing: ws-client `close()` does not begin until the scope
+    // finalizer chain has completed.
+    const closeScope = closeScopeIfPresent(serviceScope);
+    const closeClient = closeClientIfPresent(client);
+    return closeScope.pipe(Effect.zipRight(closeClient));
+}
+//# sourceMappingURL=service-teardown.js.map

package/dist/runtime/service-teardown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-teardown.js","sourceRoot":"","sources":["../../src/runtime/service-teardown.ts"],"names":[],"mappings":"AAAA,yfAAyf;AACzf,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAE7C;;;;;;;;;;;;;GAaG;AACH,SAAS,mBAAmB,CAC1B,YAAyC;IAEzC,IAAI,YAAY,KAAK,IAAI;QAAE,OAAO,MAAM,CAAC,IAAI,CAAC;IAC9C,OAAO,KAAK,CAAC,KAAK,CAAC,YAAY,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;AAC9C,CAAC;AAED,SAAS,oBAAoB,CAC3B,MAAmE;IAEnE,IAAI,MAAM,KAAK,IAAI;QAAE,OAAO,MAAM,CAAC,IAAI,CAAC;IACxC,OAAO,MAAM,CAAC,KAAK,EAAE,CAAC;AACxB,CAAC;AAED,MAAM,UAAU,sBAAsB,CACpC,YAAyC,EACzC,MAAmE;IAEnE,qEAAqE;IACrE,0EAA0E;IAC1E,iEAAiE;IACjE,iCAAiC;IACjC,MAAM,UAAU,GAAG,mBAAmB,CAAC,YAAY,CAAC,CAAC;IACrD,MAAM,WAAW,GAAG,oBAAoB,CAAC,MAAM,CAAC,CAAC;IACjD,OAAO,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC;AACvD,CAAC"}

package/dist/runtime/service-teardown.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=service-teardown.test.d.ts.map

package/dist/runtime/service-teardown.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-teardown.test.d.ts","sourceRoot":"","sources":["../../src/runtime/service-teardown.test.ts"],"names":[],"mappings":""}

package/dist/runtime/service-teardown.test.js

@@ -0,0 +1,80 @@
+/**
+ * Spec B (#596) close-ordering regression test (P2-4 r1 cleanup).
+ *
+ * `MoltZapService.close` MUST close the service-owned scope (which holds
+ * the `subscribeAll → Stream.runForEach` fan-out fiber) BEFORE invoking
+ * the ws-client's `close()`. Codex r0 caught the original two-`runFork`
+ * race; the structural fix lives in `composeServiceTeardown` and these
+ * tests pin the ordering so a future refactor can't regress.
+ *
+ * `composeServiceTeardown` is a pure Effect producer: it composes the
+ * close chain but does NOT run it. The tests await the returned Effect
+ * via `yield*`, which means by the time we read `events` the chain has
+ * fully settled — no `Effect.runFork` race in the test harness either.
+ */
+/* eslint-disable agent-code-guard/finalizer-requires-scope -- scope is the test artifact closed explicitly via composeServiceTeardown(scope, ...); no enclosing Effect.scoped frame applies here by design */
+import { describe, expect, it } from "vitest";
+import { Effect, Scope } from "effect";
+import { composeServiceTeardown } from "./service-teardown.js";
+function makeRecorder() {
+    const events = [];
+    const fakeClient = {
+        close: () => Effect.sync(() => {
+            events.push("client");
+        }),
+    };
+    return { events, fakeClient };
+}
+function makeScopeRecorder(events) {
+    // Build a `Scope.CloseableScope` whose finalizer pushes "scope" — mirrors
+    // the runtime shape (the fan-out fiber is installed as a finalizer on
+    // `serviceScope` via `Effect.forkIn` in `MoltZapService.connect`). The
+    // scope is the artifact under test and is closed explicitly via
+    // `composeServiceTeardown`; no enclosing `Effect.scoped` is needed.
+    return Effect.gen(function* () {
+        const scope = yield* Scope.make();
+        yield* Scope.addFinalizer(scope, Effect.sync(() => {
+            events.push("scope");
+        }));
+        return scope;
+    });
+}
+function teardownOrderingCloses() {
+    return Effect.runPromise(Effect.gen(function* () {
+        const { events, fakeClient } = makeRecorder();
+        const scope = yield* makeScopeRecorder(events);
+        yield* composeServiceTeardown(scope, fakeClient);
+        expect(events).toEqual(["scope", "client"]);
+    }));
+}
+function teardownNullScopeRunsClient() {
+    return Effect.runPromise(Effect.gen(function* () {
+        const { events, fakeClient } = makeRecorder();
+        yield* composeServiceTeardown(null, fakeClient);
+        expect(events).toEqual(["client"]);
+    }));
+}
+function teardownNullClientClosesScope() {
+    return Effect.runPromise(Effect.gen(function* () {
+        const events = [];
+        const scope = yield* makeScopeRecorder(events);
+        yield* composeServiceTeardown(scope, null);
+        expect(events).toEqual(["scope"]);
+    }));
+}
+function teardownBothNullIsNoop() {
+    return Effect.runPromise(Effect.gen(function* () {
+        yield* composeServiceTeardown(null, null);
+        // The Effect completed without failing — that IS the assertion. The
+        // explicit expect anchors the test name; no value to compare beyond
+        // "no throw."
+        expect(true).toBe(true);
+    }));
+}
+describe("composeServiceTeardown — Spec B close ordering (P2-4)", () => {
+    it("closes service-owned scope BEFORE invoking ws-client.close()", teardownOrderingCloses);
+    it("tolerates null scope (calls only client.close())", teardownNullScopeRunsClient);
+    it("tolerates null client (closes only the scope)", teardownNullClientClosesScope);
+    it("no-op when both inputs are null", teardownBothNullIsNoop);
+});
+//# sourceMappingURL=service-teardown.test.js.map

package/dist/runtime/service-teardown.test.js.map

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