@cotal-ai/core 0.11.6 → 0.13.0

package/dist/endpoint-verbs.js

@@ -0,0 +1,576 @@
+/**
+ * v0.4 caller-side verbs (SPEC §13.5 "Verbs", §13.2 rails, §13.3 envelope) — call, cast, watch,
+ * and scatter over the endpoint rails. The verb never changes the subject grammar (§13.2): a
+ * call and a cast publish the same request form; the verb rides `replyExpected`, and only the
+ * §13.5 gather semantics differ.
+ *
+ * Boundary discipline mirrors the serve side: args validate against the COMPILED input contract
+ * before publish (a caller never emits a request its own contract refuses), the pinned
+ * invocation digests are DERIVED from each contract's closure digest, and every consumed reply
+ * or event is runtime-validated at this, its consuming boundary (§13.3) — subject-attributed
+ * (instance + epoch from the SUBJECT, never the body), id-echoed, and schema-checked under the
+ * same fixed §13.8 budget the responder ran. Journal-class work never rides these rails: the
+ * verbs pin `class: "ephemeral"`; submissions go through the `epj` journal machinery (§13.4).
+ */
+import { randomBytes } from "node:crypto";
+import { spacePrefix } from "./subjects.js";
+import { epRequestSubject, parseEpSubject, callerTokens, assertLifecycleToken, assertBoundedOwner, } from "./endpoint-subjects.js";
+import { EpEnvelopeError, parseEndpointReply, parseEndpointEvent, assertArgsValid, assertOutputValid, } from "./endpoint-envelope.js";
+import { freezeExpectedSet, registrationReconciler, serviceEpochReader } from "./endpoint-service.js";
+const nonce = () => randomBytes(24).toString("base64url"); // 32 tokens of [A-Za-z0-9_-], 192 bits
+function subjectTarget(t) {
+    if (t.mode === "self")
+        return { mode: "self" };
+    if (t.mode === "handle")
+        return { mode: "handle", tOwner: t.owner, tActor: t.actor, tUid: t.lifecycleUid };
+    return { mode: t.mode, tOwner: t.owner };
+}
+function bodyTarget(t) {
+    if (t.mode === "self")
+        return undefined;
+    return {
+        owner: assertBoundedOwner(t.owner, "target owner"),
+        actor: t.actor,
+        lifecycleUid: assertLifecycleToken(t.lifecycleUid, "target lifecycleUid"),
+        ...(t.mappingRevision !== undefined ? { mappingRevision: t.mappingRevision } : {}),
+    };
+}
+function buildRequest(space, route, op, verb) {
+    // §13.7: the caller's own contract gates the args BEFORE publish — the same validator and the
+    // same budget the responder runs, so a request this boundary admits pins digests the
+    // responder can honor or reject, never digests detached from the payload.
+    assertArgsValid(op.contract.input.validate, op.args);
+    const n = nonce();
+    const subject = epRequestSubject(space, {
+        route, endpoint: op.endpoint, command: op.command,
+        ...(op.target ? { target: subjectTarget(op.target) } : {}),
+        caller: op.caller, nonce: n,
+    });
+    const requestId = nonce();
+    const env = {
+        v: 1,
+        id: requestId,
+        op: {
+            endpoint: op.endpoint,
+            command: op.command,
+            inputDigest: op.contract.input.closureDigest,
+            outputDigest: op.contract.output.closureDigest,
+        },
+        class: "ephemeral", // journal work rides epj submissions, never a rail verb (§13.4/§13.5)
+        replyExpected: verb.replyExpected,
+        ...(op.goalId !== undefined ? { goalId: op.goalId } : {}),
+        ...(op.target && op.target.mode !== "self" ? { target: bodyTarget(op.target) } : {}),
+        ...(op.args !== undefined ? { args: op.args } : {}),
+        from: { id: `${op.caller.owner}.${op.caller.actor}`, name: op.name ?? op.caller.actor },
+        ...(verb.deadlineMs !== undefined ? { deadlineMs: verb.deadlineMs } : {}),
+        ...(op.correlation !== undefined ? { correlation: op.correlation } : {}),
+        ...(op.auth !== undefined ? { auth: op.auth } : {}),
+    };
+    return { subject, requestId, n, body: new TextEncoder().encode(JSON.stringify(env)) };
+}
+// Node clamps a `setTimeout` delay beyond 2^31-1 ms (~24.8 days) to 1ms, so an over-large deadline
+// would fire IMMEDIATELY (an unbounded budget masquerading as a huge one). Bound every budget to the
+// timer range so the deadline the caller passes is the deadline the timer honors.
+const MAX_TIMER_MS = 2_147_483_647;
+function assertDeadline(deadlineMs, what = "deadlineMs") {
+    if (!Number.isSafeInteger(deadlineMs) || deadlineMs <= 0 || deadlineMs > MAX_TIMER_MS)
+        throw new EpEnvelopeError("bad-request", `${what} ${deadlineMs} must be a positive budget within the timer bound ${MAX_TIMER_MS}ms (SPEC 13.3: bounded, never unbounded; a larger setTimeout clamps to 1ms)`);
+    return deadlineMs;
+}
+/** A NATS "no responders" control message: the broker answered that the request subject had zero
+ *  subscribers (SPEC 13.5: no responder → unavailable), delivered to the publish reply-to as an empty
+ *  message with a 503 status header — distinct from a responder that exists but missed the deadline.
+ *  A responder CAN attach a 503 header to its own reply, so this header alone is not proof of broker
+ *  authorship: callers must trust it ONLY on the reserved no-responders sentinel subject (which carries
+ *  no responder publish grant), never on a normal reply subject. */
+function isNoRespondersMsg(msg) {
+    const h = msg.headers;
+    return h != null && (h.code === 503 || h.status === "503");
+}
+/** Race a caller-supplied read against a bounded budget so a never-settling hook cannot exceed the
+ *  operation deadline (SPEC 13.5: deadline mandatory). Clears its timer on either outcome. */
+async function raceBounded(read, ms, what) {
+    let t;
+    try {
+        return await Promise.race([
+            (async () => read())(),
+            new Promise((_, reject) => { t = setTimeout(() => reject(new EpEnvelopeError("deadline-exceeded", `${what} did not settle within the ${ms}ms budget (SPEC 13.5)`)), ms); }),
+        ]);
+    }
+    finally {
+        if (t !== undefined)
+            clearTimeout(t);
+    }
+}
+/** The caller's per-request reply subscription: its own rail narrowed to exactly this request's
+ *  nonce (contained in the §13.9 reply-read grant), so concurrent calls never see each other. */
+function replySubjectFor(space, caller, n) {
+    return `${spacePrefix(space)}.ep.reply.*.*.*.${callerTokens(caller).join(".")}.${n}`;
+}
+function parseAttributedReply(space, subject, data, requestId, op, expect) {
+    const parsed = parseEpSubject(subject);
+    if (!parsed || parsed.plane !== "reply")
+        throw new EpEnvelopeError("internal", `a message on the caller's reply rail does not parse as a reply subject: ${subject}`);
+    // §13.2 (:1173-1189): ACCEPTANCE binds the subject-borne attribution to the INVOKED identity.
+    // Reading the endpoint/instance/epoch off the subject is not the same as checking them against the
+    // invocation: a truthfully-attributed reply from a DIFFERENT endpoint (or a stale/other instance)
+    // is not the requested responder, and nonce possession is addressing, not authorization. A stale
+    // process "publishes attributably stale replies that callers reject" — so the caller rejects here.
+    if (parsed.endpoint !== op.endpoint)
+        throw new EpEnvelopeError("internal", `reply endpoint "${parsed.endpoint}" is not the invoked endpoint "${op.endpoint}" (SPEC 13.2: the caller binds a reply to the requested identity, never trusts the subject alone)`);
+    if (expect?.instanceId !== undefined && parsed.instanceId !== expect.instanceId)
+        throw new EpEnvelopeError("internal", `reply instance "${parsed.instanceId}" is not the addressed instance "${expect.instanceId}" (SPEC 13.2)`);
+    if (expect?.epoch !== undefined && parsed.epoch !== expect.epoch)
+        throw new EpEnvelopeError("expired", `reply epoch ${parsed.epoch} is not the addressed epoch ${expect.epoch}; a superseded incarnation's reply is rejected (SPEC 13.2:1187-1189)`);
+    // §13.3: an unparseable body is THIS boundary's own structured refusal — the documented catalog
+    // (`internal`) holds; a raw SyntaxError must never escape the verb (the watch path already wraps
+    // its decode the same way).
+    let rawBody;
+    try {
+        rawBody = JSON.parse(new TextDecoder().decode(data));
+    }
+    catch (e) {
+        throw new EpEnvelopeError("internal", `the reply body on the caller's rail is not JSON (${e instanceof Error ? e.message : String(e)}); an unparseable reply is a responder bug surfaced as the caller boundary's structured refusal (SPEC 13.3)`);
+    }
+    const reply = parseEndpointReply(rawBody);
+    if (reply.id !== requestId)
+        throw new EpEnvelopeError("internal", `reply id "${reply.id}" does not echo the request id "${requestId}" on its nonce-scoped rail (SPEC 13.3)`);
+    // §13.3: a success payload validates against the pinned output contract at ITS consuming
+    // boundary, under the same fixed budget; the responder's bug never parses as caller success.
+    if (reply.ok)
+        assertOutputValid(op.contract.output.validate, reply.data);
+    return { reply, responder: { endpoint: parsed.endpoint, instanceId: parsed.instanceId, epoch: parsed.epoch } };
+}
+// ---- call (§13.5: request/reply, deadline-bounded) ----------------------------------------------
+/**
+ * Call one command and await its reply within `deadlineMs`: on the `one` (queue-group anycast) or
+ * `inst` (stable incarnation) rail with `replyExpected: true`, subscribe the caller's own
+ * nonce-scoped reply subject BEFORE publishing, and resolve the first attributed reply — BOUND to
+ * the invoked identity (§13.2:1187-1189: "callers reject" stale-process replies), on BOTH rails:
+ *  - `inst` pins the addressed `(instanceId, epoch)` incarnation up front; a stale-epoch reply is
+ *    `expired` and a wrong-instance reply `internal`.
+ *  - `one` cannot pin an instance up front (the queue picks the responder), so the caller MUST supply
+ *    `currentEpoch(instanceId)`: after the reply lands, the answering incarnation's epoch is checked
+ *    against its current registry epoch, and a superseded-but-still-connected queue member's reply is
+ *    `expired`. The queue winner is NOT implicitly current — that is a check, not an assumption.
+ *
+ * Application-level failure is NOT a throw: the resolved `reply` carries `ok: false` with the
+ * responder's structured error (§13.3). This boundary throws only for its own refusals: invalid args
+ * `bad-request`; an unparseable/mis-echoed/mis-attributed reply `internal` (a raw decode error never
+ * escapes); a throwing `currentEpoch` hook `internal` and a garbled (non-integer/negative) currency
+ * value `failed-precondition` (the read's own failure, never mislabeled staleness); a stale reply `expired`;
+ * NO responder `unavailable` (SPEC 13.5:1484 — the broker's no-responders 503 lands on a reply-to that
+ * sits on THIS caller's own rail, so a manual, fully-disposed probe distinguishes it from a slow
+ * responder without leaving a lingering request); a failed reply subscription `unavailable`; the
+ * elapsed budget `deadline-exceeded`. Every subscription and timer is released in the `finally`.
+ */
+export async function epCall(nc, space, route, op, opts) {
+    const deadlineMs = assertDeadline(opts.deadlineMs);
+    if (route.mode === "one" && opts.currentEpoch === undefined)
+        throw new EpEnvelopeError("bad-request", "epCall on the `one` rail requires opts.currentEpoch: the queue winner is not implicitly current, and a superseded-but-connected member's reply must be rejected (SPEC 13.2:1187-1189)");
+    const req = buildRequest(space, route, op, { replyExpected: true, deadlineMs });
+    const expect = route.mode === "inst" ? { instanceId: route.instanceId, epoch: route.epoch } : undefined;
+    // A no-responders reply-to that lands on THIS caller's OWN rail (within its §13.9 read grant, no
+    // inbox prefix needed): responders answer on the DERIVED rail, so this sentinel only ever carries
+    // the broker's no-responders 503, which our rail subscription observes and disposes with everything
+    // else in the finally — no ghost request/subscription/timer survives a successful call.
+    const noRespReplyTo = `${spacePrefix(space)}.ep.reply._nr._nr._nr.${callerTokens(op.caller).join(".")}.${req.n}`;
+    const started = Date.now();
+    let sub;
+    let timer;
+    try {
+        const outcome = new Promise((resolve, reject) => {
+            sub = nc.subscribe(replySubjectFor(space, op.caller, req.n), {
+                callback: (err, msg) => {
+                    if (err) {
+                        reject(new EpEnvelopeError("unavailable", `the caller's reply subscription failed: ${err.message}`));
+                        return;
+                    }
+                    // Broker no-responders is authoritative ONLY on the reserved sentinel reply-to: no responder
+                    // holds a publish grant for the `_nr._nr._nr` subject (§13.9), so only the broker's control
+                    // frame reaches it. A 503 status header on a NORMAL responder subject is just a responder
+                    // frame carrying a status line — a recipient knows the nonce and could forge one to
+                    // impersonate transport absence — so it takes the ordinary attributed-reply path below, never
+                    // the broker-control path.
+                    if (msg.subject === noRespReplyTo) {
+                        if (isNoRespondersMsg(msg)) {
+                            reject(new EpEnvelopeError("unavailable", `no responder for ${op.endpoint}.${op.command} (SPEC 13.5)`));
+                            return;
+                        }
+                        reject(new EpEnvelopeError("internal", `a non-503 message reached the reserved no-responders sentinel for ${op.endpoint}.${op.command}; nothing but the broker control frame is addressable there`));
+                        return;
+                    }
+                    resolve({ subject: msg.subject, data: msg.data });
+                },
+            });
+        });
+        nc.publish(req.subject, req.body, { reply: noRespReplyTo });
+        const timeout = new Promise((_, reject) => { timer = setTimeout(() => reject(new EpEnvelopeError("deadline-exceeded", `no reply to ${op.endpoint}.${op.command} within the ${deadlineMs}ms budget (SPEC 13.5)`)), deadlineMs); });
+        const msg = await Promise.race([outcome, timeout]);
+        const attributed = parseAttributedReply(space, msg.subject, msg.data, req.requestId, op, expect);
+        if (route.mode === "one") {
+            // §13.2:1187-1189 currency for the queue winner, bounded by the REMAINING budget so the whole
+            // call stays within ONE `deadlineMs` (deliberately NOT a second dedicated budget like scatter's
+            // `reconcileDeadlineMs`: a call's reply usually arrives well before T, leaving room to verify,
+            // whereas scatter's gather deterministically eats its whole deadline). The consequence is a
+            // deliberate disposition: a VALID reply that lands with no budget left to verify currency is
+            // `deadline-exceeded`, not the reply — the operation could not complete-and-verify within its
+            // budget. Recorded for the panel's §13.5 reconciliation (dedicated one-rail currency budget?).
+            const remaining = deadlineMs - (Date.now() - started);
+            if (remaining <= 0)
+                throw new EpEnvelopeError("deadline-exceeded", `no budget left to verify the \`one\` responder's currency within ${deadlineMs}ms (SPEC 13.5)`);
+            // The hook is an untrusted caller-supplied boundary (same class as scatter's reconcile): its
+            // own throw is normalized into the documented catalog, and its VALUE is runtime-fenced — a
+            // NaN/garbled epoch compares unequal to any real epoch and would masquerade as staleness
+            // (`expired`), mislabeling a valid reply; fail loud as the read's own failure instead.
+            let cur;
+            try {
+                cur = await raceBounded(() => opts.currentEpoch(attributed.responder.instanceId), remaining, `the \`one\` currency read for ${op.endpoint}.${op.command}`);
+            }
+            catch (e) {
+                if (e instanceof EpEnvelopeError)
+                    throw e; // the bound's deadline-exceeded, or the hook's own structured refusal
+                throw new EpEnvelopeError("internal", `the \`one\` currency read threw (${e instanceof Error ? e.message : String(e)}); the documented error catalog holds at this boundary (SPEC 13.3)`);
+            }
+            if (!Number.isSafeInteger(cur) || cur < 0)
+                throw new EpEnvelopeError("failed-precondition", `the \`one\` currency read returned a non-integer/negative epoch ${String(cur)}; a garbled currency read is refused as the read's own failure, never reported as responder staleness (SPEC 13.2)`);
+            if (attributed.responder.epoch !== cur)
+                throw new EpEnvelopeError("expired", `the \`one\` responder ${attributed.responder.instanceId} answered at epoch ${attributed.responder.epoch}, not its current ${cur}; a superseded incarnation's reply is rejected (SPEC 13.2:1187-1189)`);
+        }
+        return attributed;
+    }
+    finally {
+        sub?.unsubscribe();
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+// ---- cast (§13.5: at-most-once, never replied) --------------------------------------------------
+/**
+ * Cast one command: the same request form with `replyExpected: false` — the responder never
+ * replies, even on failure (§13.5 at-most-once), so this resolves once the request is flushed to
+ * the broker. `deadlineMs` is optional and advisory for `one`/`inst` (the envelope requires it only
+ * for calls and journal submissions, §13.3), but MANDATORY for `all`: §13.2's
+ * `checkRequestSubjectAgreement` refuses an all-rail request without a deadline regardless of
+ * `replyExpected`, and a cast has no reply on which that refusal could surface — so an all-cast
+ * without a deadline would be silently dropped by every responder. Fail loud at the caller instead.
+ */
+export async function epCast(nc, space, route, op, opts = {}) {
+    if (route.mode === "all" && opts.deadlineMs === undefined)
+        throw new EpEnvelopeError("bad-request", "an all-rail cast (scatter) requires deadlineMs (SPEC 13.2: checkRequestSubjectAgreement refuses an all request without a deadline; a cast has no reply to carry that refusal, so it would be silently dropped)");
+    const req = buildRequest(space, route, op, {
+        replyExpected: false,
+        ...(opts.deadlineMs !== undefined ? { deadlineMs: assertDeadline(opts.deadlineMs) } : {}),
+    });
+    nc.publish(req.subject, req.body);
+    await nc.flush();
+}
+/**
+ * Watch a granted `epe` subtree LIVE (the event half of §13.5 `watch`; §13.9: the read grant is the
+ * caller's own `sub.allow` row, e.g. the per-goal progress subtree — delivery lands only on this
+ * caller's own subscription). Every event is validated at this consuming boundary: an unparseable
+ * subject or body is reported through `onError` (§13.3: fail loud, never a silent drop) and never
+ * reaches `onEvent`. This is the LIVE tap ONLY — durable catch-up / filtered replay is the §13.9
+ * mediated read (see the module note above), and record watch is `watchRecord` (§13.4).
+ */
+export function epWatchEvents(nc, space, filter, handlers) {
+    if (!filter.startsWith(`${spacePrefix(space)}.epe.`))
+        throw new Error(`epWatchEvents filter "${filter}" is not an epe subtree of space "${space}" (SPEC 13.9: watch reads the event plane)`);
+    const sub = nc.subscribe(filter, {
+        callback: (err, msg) => {
+            if (err) {
+                handlers.onError(new EpEnvelopeError("unavailable", `the watch subscription failed: ${err.message}`));
+                return;
+            }
+            const parsed = parseEpSubject(msg.subject);
+            if (!parsed || parsed.plane !== "event") {
+                handlers.onError(new EpEnvelopeError("internal", `a message on the watch filter does not parse as an event subject: ${msg.subject}`));
+                return;
+            }
+            let event;
+            try {
+                event = parseEndpointEvent(JSON.parse(new TextDecoder().decode(msg.data)));
+            }
+            catch (e) {
+                handlers.onError(e instanceof EpEnvelopeError ? e : new EpEnvelopeError("internal", `event body does not decode: ${e.message}`));
+                return;
+            }
+            handlers.onEvent({ endpoint: parsed.endpoint, instanceId: parsed.instanceId, epoch: parsed.epoch, topic: parsed.topic, event });
+        },
+    });
+    return { stop: () => sub.drain() };
+}
+/**
+ * Scatter one command to a FROZEN expected set (§13.5): publish once on the `all` rail, gather
+ * attributed replies on the caller's nonce-scoped rail, and CLASSIFY against the freeze. An empty set
+ * refuses (`failed-precondition`, never an empty success), and the observation channel is fail-loud:
+ * a failed reply subscription is `unavailable`, never fabricated member silence.
+ *
+ * CLASSIFICATION LINEARIZES AT THE GATHER DEADLINE. The classification point T is `min(all frozen
+ * slots answered-valid, deadline)`; `missing` is fixed at T (from the `respondedAtDeadline` snapshot).
+ * The `lateDrainMs` window runs AFTER T on an ABSOLUTE clock — the rail is closed exactly `lateDrainMs`
+ * after T regardless of how long the reconcile takes, so late classification cannot leak past the
+ * requested horizon. It is OBSERVATIONAL only: it may add to `late`/`duplicate`, never move
+ * `missing`/`churn`/`complete`. With `lateDrainMs` omitted the rail closes at T (no `late`).
+ *
+ * WHOLE-OPERATION BUDGET. The op is bounded: the gather to T comes FIRST, then a post-T phase in which
+ * the reconcile and the drain run CONCURRENTLY (the drain is armed at T, before the reconcile await).
+ * So worst-case wall-clock ≈ `deadlineMs` (gather) + `max(reconcileDeadlineMs, lateDrainMs)` (post-T),
+ * NOT their sum. The reconcile is a bounded read taken SHORTLY AFTER T (not a zero-width at-T snapshot):
+ * a true instant-of-T revision would need a watch/frontier, so a re-registration strictly concurrent
+ * with the bounded read is an inherent, documented window (recorded for the §13.5 SPEC reconciliation).
+ *
+ * Two §13.5 signals are not on the reply rail, so the caller supplies them as HOOKS (keeping the verb
+ * free of storage coupling; the §13.9 read grant stays with the caller, and a caller-read revision is
+ * more trustworthy than a responder-stamped one):
+ *  - `reconcileRegistration` (REQUIRED): reads EVERY frozen slot's CURRENT state after the classification
+ *    point, returning a per-instance `EpRegistrationState` verdict. A slot still registered at a revision
+ *    ADVANCED past its frozen one is `churn` ("registration") and uncounted (a re-registration advances
+ *    registrationRevision WITHOUT advancing the epoch, so the reply rail cannot see it). A slot the read
+ *    observed as GONE (`{ registered: false }`) is an explicit mid-scatter deregistration: NOT churn, and
+ *    a valid reply it already gave still counts (a plain departure does not invalidate the reply the way
+ *    a re-registration would). Its result is COMPLETENESS-validated: a frozen id ABSENT from the returned
+ *    Map is an incomplete read (`failed-precondition`) — distinct from an explicit `{ registered: false }`
+ *    verdict — a non-integer/non-positive revision is a garbled read (`failed-precondition`), and a
+ *    revision BELOW the frozen one is a non-monotonic/buggy read (`failed-precondition`); otherwise a
+ *    partial hook would silently preserve the old full-triple over-claim. It is BOUNDED by
+ *    `reconcileDeadlineMs`: a never-settling read is `unavailable`, never a hung scatter (SPEC 13.5:
+ *    deadline mandatory); an unreadable registry is `failed-precondition`. Authoritative `complete`
+ *    requires it.
+ *  - `reconcileDeadlineMs` (optional, default `deadlineMs`): the explicit bound on that post-T read,
+ *    named so the single `deadlineMs` is not silently spent twice.
+ *  - `lateDrainMs` (optional): the absolute post-T horizon for `late` classification. Omitted → none.
+ */
+export async function epScatter(nc, space, op, opts) {
+    const deadlineMs = assertDeadline(opts.deadlineMs);
+    const reconcileDeadlineMs = opts.reconcileDeadlineMs !== undefined ? assertDeadline(opts.reconcileDeadlineMs, "reconcileDeadlineMs") : deadlineMs;
+    const lateDrainMs = opts.lateDrainMs !== undefined ? assertDeadline(opts.lateDrainMs, "lateDrainMs") : 0;
+    if (opts.expected.length === 0)
+        throw new EpEnvelopeError("failed-precondition", "scatter requires a non-empty frozen expected set (SPEC 13.5: an empty registry is never an empty success)");
+    const frozen = new Map();
+    for (const slot of opts.expected) {
+        const iId = assertLifecycleToken(slot.instanceId, "instanceId");
+        // Validate the frozen (epoch, registrationRevision) coordinates at this public ingress: an untyped
+        // adapter that handed in a NaN/float/negative would otherwise slip past the currency and
+        // monotonicity fences downstream (a NaN compares false both ways). Epoch is a non-negative safe
+        // integer (the subject epoch), registrationRevision a positive safe integer (a KV revision, §13.7).
+        if (!Number.isSafeInteger(slot.epoch) || slot.epoch < 0)
+            throw new EpEnvelopeError("bad-request", `frozen instance ${iId} has a non-integer/negative epoch ${slot.epoch}; a frozen coordinate must be a safe integer so an untyped adapter cannot disable the currency fence (§13.2)`);
+        if (!Number.isSafeInteger(slot.registrationRevision) || slot.registrationRevision <= 0)
+            throw new EpEnvelopeError("bad-request", `frozen instance ${iId} has a non-integer/non-positive registrationRevision ${slot.registrationRevision}; a frozen coordinate must be a positive safe integer so an untyped adapter cannot disable the monotonicity fence (§13.7)`);
+        if (frozen.has(iId))
+            throw new EpEnvelopeError("failed-precondition", `the frozen expected set names instance ${iId} twice`);
+        frozen.set(iId, { epoch: slot.epoch, registrationRevision: slot.registrationRevision });
+    }
+    const req = buildRequest(space, { mode: "all" }, op, { replyExpected: true, deadlineMs });
+    const result = { complete: false, replies: new Map(), missing: [], unexpected: [], churn: [], duplicate: [], late: [], invalid: [] };
+    const terminal = new Set(); // frozen slots with a VALID frozen-epoch reply (drives early completion)
+    const seen = new Set(); // "(instanceId,epoch)" pairs already classified non-invalid (drives §13.5 duplicate)
+    const responded = new Set(); // frozen slots that produced ANY reply (live)
+    const regChurned = new Set();
+    const failMsg = (e) => (e instanceof Error ? e.message : String(e));
+    let respondedAtDeadline; // `responded` snapshotted at the classification point
+    let deadlinePassed = false;
+    let subError;
+    // Classify one reply; returns true when every frozen slot has a VALID reply (early completion).
+    const handle = (subject, data) => {
+        const parsed = parseEpSubject(subject);
+        if (!parsed || parsed.plane !== "reply")
+            return false; // not a reply subject: no sender, MUST NOT be handled (§13.2)
+        const { instanceId, epoch } = parsed;
+        // §13.2 endpoint binding BEFORE slot matching: instanceIds are unique only within (space,
+        // endpoint), so a truthfully-attributed reply from a DIFFERENT endpoint with a colliding
+        // (instanceId, epoch) must never satisfy a frozen slot.
+        if (parsed.endpoint !== op.endpoint) {
+            result.unexpected.push({ instanceId, epoch });
+            return false;
+        }
+        const slot = frozen.get(instanceId);
+        if (slot === undefined) {
+            result.unexpected.push({ instanceId, epoch });
+            return false;
+        }
+        responded.add(instanceId);
+        const key = `${instanceId}:${epoch}`;
+        // §13.5 duplicate: a second reply from the SAME (instanceId, epoch) after its first NON-INVALID
+        // classification (valid | churn-epoch | late) — reported, first wins. An invalid frame never marks
+        // the coordinate seen, so a later valid frame from it is NOT mislabeled duplicate.
+        if (seen.has(key)) {
+            result.duplicate.push({ instanceId, epoch });
+            return false;
+        }
+        if (epoch !== slot.epoch) {
+            result.churn.push({ instanceId, epoch, reason: "epoch" });
+            seen.add(key);
+            return false;
+        }
+        if (deadlinePassed) {
+            // Post-deadline, frozen epoch: a first VALID reply is LATE (observational, uncounted); a boundary
+            // failure is `invalid` (NON-terminal — the coordinate stays un-seen).
+            try {
+                parseAttributedReply(space, subject, data, req.requestId, op);
+                result.late.push({ instanceId, epoch });
+                seen.add(key);
+            }
+            catch (e) {
+                result.invalid.push({ instanceId, epoch, message: failMsg(e) });
+            }
+            return false;
+        }
+        // Pre-deadline, frozen epoch. An invalid frame is NON-TERMINAL: reported, the slot stays open to a
+        // later valid reply, the coordinate stays un-seen, and it never triggers early completion.
+        try {
+            result.replies.set(instanceId, parseAttributedReply(space, subject, data, req.requestId, op));
+        }
+        catch (e) {
+            result.invalid.push({ instanceId, epoch, message: failMsg(e) });
+            return false;
+        }
+        terminal.add(instanceId);
+        seen.add(key);
+        return terminal.size === frozen.size;
+    };
+    let sub;
+    // Phase 1 — gather to the classification point T = min(all-valid, deadline). NO drain here; the drain
+    // is a later observational phase so it can never move the classification.
+    await new Promise((resolve) => {
+        const finishAtT = () => { if (respondedAtDeadline === undefined)
+            respondedAtDeadline = new Set(responded); };
+        const timer = setTimeout(() => { deadlinePassed = true; finishAtT(); resolve(); }, deadlineMs);
+        sub = nc.subscribe(replySubjectFor(space, op.caller, req.n), {
+            callback: (err, msg) => {
+                if (err) {
+                    subError ??= err;
+                    finishAtT();
+                    clearTimeout(timer);
+                    resolve();
+                    return;
+                } // fail loud, never fake `missing`
+                if (handle(msg.subject, msg.data)) {
+                    finishAtT();
+                    clearTimeout(timer);
+                    resolve();
+                }
+            },
+        });
+        nc.publish(req.subject, req.body);
+    });
+    let drainTimer;
+    try {
+        if (subError !== undefined)
+            throw new EpEnvelopeError("unavailable", `the scatter reply subscription failed; without a working observation channel member silence cannot be classified, never fabricated (SPEC 13.5): ${failMsg(subError)}`);
+        // The late window is an ABSOLUTE horizon from T: close the rail exactly `lateDrainMs` after T
+        // (early completion has no window), independent of how long the reconcile below runs — so a reply
+        // during a slow reconcile is NOT misclassified `late`, and with no `lateDrainMs` the rail closes
+        // now. Runs concurrently with the reconcile.
+        const drainMs = deadlinePassed ? lateDrainMs : 0;
+        const drainDone = new Promise((resolve) => {
+            if (drainMs > 0)
+                drainTimer = setTimeout(() => { sub?.unsubscribe(); resolve(); }, drainMs);
+            else {
+                sub?.unsubscribe();
+                resolve();
+            }
+        });
+        // Reconcile shortly after T, bounded by its OWN explicit budget (not a second full `deadlineMs`):
+        // a never-settling read is `unavailable`, an unreadable registry `failed-precondition`.
+        let current;
+        let reconcileTimer;
+        try {
+            current = await Promise.race([
+                opts.reconcileRegistration(),
+                new Promise((_, reject) => { reconcileTimer = setTimeout(() => reject(new EpEnvelopeError("unavailable", `the scatter registration reconcile did not settle within its ${reconcileDeadlineMs}ms bound (SPEC 13.5: deadline mandatory, never a hung scatter)`)), reconcileDeadlineMs); }),
+            ]);
+        }
+        catch (e) {
+            if (e instanceof EpEnvelopeError && e.code === "unavailable")
+                throw e; // the reconcile bound
+            throw new EpEnvelopeError("failed-precondition", `the scatter registration reconcile is unreadable; an unreadable registry is failed-precondition, never an empty success (SPEC 13.5): ${failMsg(e)}`);
+        }
+        finally {
+            if (reconcileTimer !== undefined)
+                clearTimeout(reconcileTimer);
+        }
+        // COMPLETENESS + MONOTONICITY: the mandatory reconcile must return an EXPLICIT verdict for every
+        // frozen slot, else a partial/buggy read would silently preserve the old full-triple over-claim.
+        // An ABSENT Map entry is an incomplete read (fail-loud) — distinct from an explicit deregistration
+        // verdict. A still-registered slot's revision below-frozen is non-monotonic (revisions only advance
+        // on mediated registration writes, §13.7), a NaN/non-integer one is garbled: both fail-loud. An
+        // advanced revision is registration-churn (drops the counted reply). An explicit deregistration is
+        // NOT churn: a valid reply the instance already gave still counts, and if it never replied its slot
+        // falls to `missing` below.
+        for (const [instanceId, slot] of frozen) {
+            const state = current.get(instanceId);
+            if (state === undefined)
+                throw new EpEnvelopeError("failed-precondition", `the reconcile returned no verdict for frozen instance ${instanceId}; an incomplete registration read cannot authorize completion, and an absent Map entry is NOT an implicit deregistration (SPEC 13.5)`);
+            // RUNTIME-validate the discriminant at this untrusted boundary (TS alone cannot fence a
+            // caller-supplied/legacy hook): the verdict MUST be an explicit `{ registered: boolean }`. A bare
+            // number, `{}`, or `{ registered: 0 }` must FAIL LOUD, never fall through the falsy check below as
+            // an implicit deregistration and bypass the completeness fence the typed result exists to enforce.
+            if (typeof state !== "object" || state === null || typeof state.registered !== "boolean")
+                throw new EpEnvelopeError("failed-precondition", `the reconcile verdict for instance ${instanceId} is not a typed { registered: boolean } state; an untyped/legacy value must never masquerade as a deregistration (SPEC 13.5)`);
+            if (state.registered === false)
+                continue; // explicit mid-scatter deregistration: not churn; a prior reply still counts
+            const now = state.registrationRevision;
+            if (!Number.isSafeInteger(now) || now <= 0)
+                throw new EpEnvelopeError("failed-precondition", `the reconcile reports instance ${instanceId} at a non-integer/non-positive registrationRevision ${now}; a NaN or garbled value is neither below nor above the frozen revision and would silently disable the monotonicity fence (§13.7), so it is refused, never a counted completion`);
+            if (now < slot.registrationRevision)
+                throw new EpEnvelopeError("failed-precondition", `the reconcile reports instance ${instanceId} at registrationRevision ${now}, below its frozen ${slot.registrationRevision}; registration revisions are monotonic (§13.7), so a lower value is a buggy/unreadable read`);
+            if (now > slot.registrationRevision) {
+                result.replies.delete(instanceId);
+                result.churn.push({ instanceId, epoch: slot.epoch, reason: "registration" });
+                regChurned.add(instanceId);
+            }
+        }
+        await drainDone; // let the absolute late window fully elapse (observational) before finalizing
+    }
+    finally {
+        if (drainTimer !== undefined)
+            clearTimeout(drainTimer);
+        sub?.unsubscribe();
+    }
+    const respondedT = respondedAtDeadline ?? responded;
+    for (const instanceId of frozen.keys())
+        if (!respondedT.has(instanceId) && !regChurned.has(instanceId))
+            result.missing.push(instanceId);
+    // Coverage completion: every frozen slot has a counted valid reply, none reg-churned (drops
+    // replies.size), no missing, and NO observed invalid frame (fail-loud: an invalid is not clean).
+    result.complete = result.missing.length === 0 && result.invalid.length === 0 && result.replies.size === frozen.size;
+    return result;
+}
+// ---- the registry-wired caller entry points (§13.5) ---------------------------------------------
+/**
+ * Scatter one command to the LIVE class (§13.5), registry-wired end to end: freeze the expected
+ * set from the service registry, publish once on the `all` rail, and reconcile registration
+ * currency post-T — the full §13.5 sequence behind one call. `jsm` drives the LEADER-served
+ * coordinate reads (the freeze's per-slot spec/status and the reconcile), `kv` the bounded-lag
+ * instance enumeration; every freeze/reconcile refusal (`failed-precondition` on an empty or
+ * unreadable registry, `internal` on malformed mediated-writer state) and every gather
+ * classification passes through unchanged. The hooks stay public: a caller composing its own
+ * freeze (a pinned set, a test harness) uses {@link epScatter} directly.
+ */
+export async function epScatterService(nc, jsm, kv, space, op, opts) {
+    // ONE ABSOLUTE deadline covers the whole op (distsys BLOCKING 2): the freeze (kv.keys enumeration
+    // + per-slot leader reads) is charged against `deadlineMs`, not run unbounded before it. A freeze
+    // that never settles is `deadline-exceeded`, never a scatter that silently overruns its budget,
+    // and the gather runs on the REMAINING budget.
+    const deadlineMs = assertDeadline(opts.deadlineMs);
+    const started = Date.now();
+    const expected = await raceBounded(() => freezeExpectedSet(jsm, kv, space, op.endpoint), deadlineMs, `the scatter freeze for ${op.endpoint}`);
+    const remaining = deadlineMs - (Date.now() - started);
+    if (remaining <= 0)
+        throw new EpEnvelopeError("deadline-exceeded", `the scatter freeze for ${op.endpoint} consumed the whole ${deadlineMs}ms budget; no time left to gather (SPEC 13.5)`);
+    return epScatter(nc, space, op, { ...opts, deadlineMs: remaining, expected, reconcileRegistration: registrationReconciler(jsm, space, op.endpoint, expected) });
+}
+/**
+ * Call one command with the registry-wired currency check (§13.2): on the `one` rail the queue
+ * winner's epoch is verified against a LEADER-served read of its `svc….status` through
+ * {@link serviceEpochReader}; the `inst` rail pins its incarnation up front and needs no read, so
+ * the hook is not wired there. Every {@link epCall} refusal passes through unchanged (a superseded
+ * winner is `expired`; an unregistered or never-converged responder is the read's own
+ * `failed-precondition`, never mislabeled staleness).
+ */
+export async function epCallService(nc, jsm, space, route, op, opts) {
+    return epCall(nc, space, route, op, route.mode === "one" ? { ...opts, currentEpoch: serviceEpochReader(jsm, space, op.endpoint) } : opts);
+}
+//# sourceMappingURL=endpoint-verbs.js.map

package/dist/endpoint-verbs.js.map

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