@cotal-ai/core 0.12.0 → 0.13.0

package/dist/endpoint-verbs.d.ts

@@ -0,0 +1,277 @@
+import type { NatsConnection } from "@nats-io/transport-node";
+import { type EpCaller, type EpRoute } from "./endpoint-subjects.js";
+import { EpEnvelopeError, type EndpointReply, type EndpointEvent, type EpCorrelation } from "./endpoint-envelope.js";
+import type { KV } from "@nats-io/kv";
+import type { JetStreamManager } from "@nats-io/jetstream";
+import type { CompiledContract } from "./schema-profile.js";
+import { type FrozenInstance } from "./endpoint-service.js";
+/** A verb's target: one input shape that builds BOTH halves of the §13.2/§13.3 targeted form —
+ *  the subject's authorization-mode token block and the body target block — so they can never
+ *  disagree. `self` carries no body target (the caller triple IS the target, §13.3). */
+export type EpVerbTarget = {
+    mode: "self";
+} | {
+    mode: "owner" | "any" | "child" | "ledger" | "handle";
+    owner: string;
+    actor: string;
+    lifecycleUid: string;
+    mappingRevision?: number;
+};
+/** What every verb needs to address one command: the compiled §13.7 contracts (digests derive
+ *  from `closureDigest`, exactly like the serve table), the caller triple the credential pins,
+ *  and an optional display name for the advisory `from.name`. */
+export interface EpVerbOp {
+    endpoint: string;
+    command: string;
+    contract: {
+        input: CompiledContract;
+        output: CompiledContract;
+    };
+    caller: EpCaller;
+    args?: Record<string, unknown>;
+    target?: EpVerbTarget;
+    correlation?: EpCorrelation;
+    /** Opaque signed authorization-context slot (§13.3); carried as-is. */
+    auth?: string;
+    goalId?: string;
+    /** Advisory display name for `from.name`; `from.id` is DERIVED from the caller triple, so it
+     *  always equals the broker-authenticated sender principal (§13.3). */
+    name?: string;
+}
+/** One attributed reply: the structural attribution comes from the reply SUBJECT (§13.2), never
+ *  from the body. */
+export interface EpAttributedReply {
+    reply: EndpointReply;
+    responder: {
+        endpoint: string;
+        instanceId: string;
+        epoch: number;
+    };
+}
+/**
+ * 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 declare function epCall(nc: NatsConnection, space: string, route: {
+    mode: "one";
+} | {
+    mode: "inst";
+    instanceId: string;
+    epoch: number;
+}, op: EpVerbOp, opts: {
+    deadlineMs: number;
+    currentEpoch?: (instanceId: string) => Promise<number> | number;
+}): Promise<EpAttributedReply>;
+/**
+ * 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 declare function epCast(nc: NatsConnection, space: string, route: EpRoute, op: EpVerbOp, opts?: {
+    deadlineMs?: number;
+}): Promise<void>;
+/** One attributed event: identity and epoch come from the SUBJECT (§13.2: forge-locked tokens;
+ *  a stale-epoch event is attributably stale — surfaced, never hidden). */
+export interface EpAttributedEvent {
+    endpoint: string;
+    instanceId: string;
+    epoch: number;
+    topic: string[];
+    event: EndpointEvent;
+}
+export interface EpWatchHandle {
+    stop(): Promise<void>;
+}
+/**
+ * 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 declare function epWatchEvents(nc: NatsConnection, space: string, filter: string, handlers: {
+    onEvent: (ev: EpAttributedEvent) => void;
+    onError: (err: EpEnvelopeError) => void;
+}): EpWatchHandle;
+/** The scatter gathers against a request-scoped FROZEN expected set (§13.5): the live instances of
+ *  the class, each `(instanceId, registrationRevision, epoch)` at send time. This is exactly
+ *  {@link import("./endpoint-service.js").freezeExpectedSet}'s output — pass it through so the freeze
+ *  identity (all THREE coordinates, not just instance+epoch) is what the gather classifies against. */
+export type EpScatterSlot = FrozenInstance;
+/** Why a frozen slot's reply is churn (§13.5): `epoch` — it replied at a DIFFERENT process epoch than
+ *  frozen (a takeover restarted it); `registration` — its `svc….spec` registrationRevision advanced
+ *  past the frozen value (a re-registration re-declared its surface). Both mean the reply may be from
+ *  an incarnation that never saw this request, so it does NOT count toward completion. Registration
+ *  churn is NOT visible on the reply rail (the reply subject carries epoch, not registrationRevision,
+ *  and a re-registration does not advance the epoch), so it is observed only when a registration
+ *  reconcile runs (see {@link epScatter} `reconcileRegistration`). */
+export type EpChurnReason = "epoch" | "registration";
+/** The §13.5 scatter outcome. `complete` means EXPECTED-SLOT COVERAGE — every frozen slot produced
+ *  exactly one counted valid reply at its frozen `(epoch, registrationRevision)`, verified against the
+ *  registration reconcile — NOT that the gather was anomaly-free. `missing` and `invalid` force
+ *  `complete` false; a `registration`-churn drops a slot's counted reply (so that slot becomes
+ *  uncovered → false). But `duplicate`, `unexpected`, and an `epoch`-churn reply do NOT by themselves
+ *  force false: a slot that answered validly at its frozen epoch stays counted even if a stray
+ *  different-epoch reply from another incarnation also arrived. First valid reply per frozen
+ *  `(instanceId, epoch)` wins. */
+export interface EpScatterResult {
+    complete: boolean;
+    /** instanceId → the first VALID attributed reply from that frozen slot at its frozen epoch. */
+    replies: Map<string, EpAttributedReply>;
+    /** Frozen slots with NO reply of any kind by the DEADLINE (the classification point). A slot that
+     *  produced only churn/duplicate/invalid is reported there. A slot that produced ONLY a `late` reply
+     *  is BOTH `missing` (no on-time reply) and `late` (observational): classification linearizes at the
+     *  deadline, and the drain enriches, never moves it. */
+    missing: string[];
+    /** Replies from a DIFFERENT endpoint, or from an instance OUTSIDE the frozen set. Never count. */
+    unexpected: {
+        instanceId: string;
+        epoch: number;
+    }[];
+    /** Frozen slots whose reply came from a superseded incarnation — a DIFFERENT epoch, or (via the
+     *  mandatory `reconcileRegistration`) an advanced registrationRevision. Does NOT count. */
+    churn: {
+        instanceId: string;
+        epoch: number;
+        reason: EpChurnReason;
+    }[];
+    /** Second-and-later replies from a frozen `(instanceId, epoch)` after its first classified one:
+     *  REPORTED, never silently dropped (§13.5); first reply wins, whatever it was classified. */
+    duplicate: {
+        instanceId: string;
+        epoch: number;
+    }[];
+    /** Valid frozen-slot replies observed AFTER the deadline, during the optional bounded `lateDrainMs`
+     *  window: too late to count, reported not dropped. Empty unless `lateDrainMs` set. */
+    late: {
+        instanceId: string;
+        epoch: number;
+    }[];
+    /** Frozen-slot replies that failed this consuming boundary (unparseable body, id mismatch, invalid
+     *  success payload, mis-attributed). NON-TERMINAL: an invalid frame does NOT consume the slot's one
+     *  terminal reply — the slot stays open to a later valid reply, bounded by the deadline. But any
+     *  recorded invalid keeps `complete` false (§13.3 fail-loud: an observed anomaly is not clean).
+     *  Not a §13.5-enumerated bucket; kept because fail-loud forbids counting an invalid reply as valid. */
+    invalid: {
+        instanceId: string;
+        epoch: number;
+        message: string;
+    }[];
+}
+/** The reconcile hook's per-instance verdict. An instance STILL in the registry carries its current
+ *  `registrationRevision`; one the mediated §13.9 read observed as GONE is `{ registered: false }`.
+ *  This is an EXPLICIT value, distinct from an absent Map entry — an absent entry stays an incomplete
+ *  read (`failed-precondition`), so a buggy/partial hook can never masquerade as "everyone deregistered".
+ *  A mid-scatter deregistration is NOT registration-churn (a re-registration advances the revision and
+ *  invalidates the reply; a plain departure does not): a valid reply the instance already gave still
+ *  counts, and if it never replied its slot falls to `missing`. */
+export type EpRegistrationState = {
+    registered: true;
+    registrationRevision: number;
+} | {
+    registered: false;
+};
+/**
+ * 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 declare function epScatter(nc: NatsConnection, space: string, op: EpVerbOp, opts: {
+    deadlineMs: number;
+    expected: EpScatterSlot[];
+    reconcileRegistration: () => Promise<Map<string, EpRegistrationState>>;
+    reconcileDeadlineMs?: number;
+    lateDrainMs?: number;
+}): Promise<EpScatterResult>;
+/**
+ * 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 declare function epScatterService(nc: NatsConnection, jsm: JetStreamManager, kv: KV, space: string, op: EpVerbOp, opts: {
+    deadlineMs: number;
+    reconcileDeadlineMs?: number;
+    lateDrainMs?: number;
+}): Promise<EpScatterResult>;
+/**
+ * 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 declare function epCallService(nc: NatsConnection, jsm: JetStreamManager, space: string, route: {
+    mode: "one";
+} | {
+    mode: "inst";
+    instanceId: string;
+    epoch: number;
+}, op: EpVerbOp, opts: {
+    deadlineMs: number;
+}): Promise<EpAttributedReply>;
+//# sourceMappingURL=endpoint-verbs.d.ts.map

package/dist/endpoint-verbs.d.ts.map

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