@moltzap/client 2026.519.0 → 2026.519.2

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/errors.d.ts

@@ -8,17 +8,4 @@ export declare class AgentNotFoundError extends AgentNotFoundError_base<{
 }> {
     get message(): string;
 }
-declare const DuplicateServerRpcHandlerError_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: "DuplicateServerRpcHandlerError";
-} & Readonly<A>;
-/**
- * `MoltZapWsClient.handleServerRpc` was called twice for the same method.
- * Multiple registrations would silently shadow each other; the typed error
- * forces the duplicate registration to surface at the call site.
- */
-export declare class DuplicateServerRpcHandlerError extends DuplicateServerRpcHandlerError_base<{
-    readonly method: string;
-}> {
-    get message(): string;
-}
 //# sourceMappingURL=errors.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/runtime/errors.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;;;;AAExD,+CAA+C;AAC/C,qBAAa,kBAAmB,SAAQ,wBAAuC;IAC7E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED;;;;GAIG;AACH,qBAAa,8BAA+B,SAAQ,oCAElD;IACA,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/runtime/errors.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;;;;AAExD,+CAA+C;AAC/C,qBAAa,kBAAmB,SAAQ,wBAAuC;IAC7E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF"}

package/dist/runtime/errors.js

@@ -9,14 +9,4 @@ export class AgentNotFoundError extends Data.TaggedError("AgentNotFoundError") {
         return `Agent not found: ${this.agentName}`;
     }
 }
-/**
- * `MoltZapWsClient.handleServerRpc` was called twice for the same method.
- * Multiple registrations would silently shadow each other; the typed error
- * forces the duplicate registration to surface at the call site.
- */
-export class DuplicateServerRpcHandlerError extends Data.TaggedError("DuplicateServerRpcHandlerError") {
-    get message() {
-        return `Server RPC handler already registered for method: ${this.method}`;
-    }
-}
 //# sourceMappingURL=errors.js.map

package/dist/runtime/errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/runtime/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B,yEAAyE;AACzE,mEAAmE;AACnE,0CAA0C;AAC1C,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,+CAA+C;AAC/C,MAAM,OAAO,kBAAmB,SAAQ,IAAI,CAAC,WAAW,CAAC,oBAAoB,CAE3E;IACA,IAAa,OAAO;QAClB,OAAO,oBAAoB,IAAI,CAAC,SAAS,EAAE,CAAC;IAC9C,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,OAAO,8BAA+B,SAAQ,IAAI,CAAC,WAAW,CAClE,gCAAgC,CAGhC;IACA,IAAa,OAAO;QAClB,OAAO,qDAAqD,IAAI,CAAC,MAAM,EAAE,CAAC;IAC5E,CAAC;CACF"}
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/runtime/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B,yEAAyE;AACzE,mEAAmE;AACnE,0CAA0C;AAC1C,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,+CAA+C;AAC/C,MAAM,OAAO,kBAAmB,SAAQ,IAAI,CAAC,WAAW,CAAC,oBAAoB,CAE3E;IACA,IAAa,OAAO;QAClB,OAAO,oBAAoB,IAAI,CAAC,SAAS,EAAE,CAAC;IAC9C,CAAC;CACF"}

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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"}