keri-ts 2.0.1 → 2.2.0

package/types/app/runtime/ipex-auxiliaries.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Runtime-owned registry of IPEX auxiliary owners (DH and Unblind), keyed by local identifier.
+ *
+ * The runtime registers one query receiver and one reply resource per route. Both resolve the
+ * addressed local identifier at dispatch time and create that identifier's owner then, so a wallet
+ * with several identifiers needs no owner before the first message and no hook when an identifier
+ * is made, joined or reloaded.
+ *
+ * Dispatch key: an `/ipex/*` message carries the sender (`pre`) and the transaction id (`q.x` for
+ * a query, `a.x` for a reply) but no recipient. The addressed local identifier is, from stored state:
+ * the holder of an approved operation for that id; for DH the recipient of a Grant `sender` opened in
+ * that transaction, and for Unblind the sender of a Grant addressed to `sender`; and, for a local
+ * group, itself when it is `sender` (its own members' contributions, which KRAM must pool). Exactly one
+ * such identifier owns the message; none or several leave it unowned, which is exactly a runtime without
+ * that owner: queries drop as `missingProcessor` before KRAM, and replies fail with the Router's
+ * missing-route error. Creating an owner grants no consent.
+ */
+import type { SerderKERI } from "cesr-ts";
+import { Dhke } from "../../acdc/dhking.js";
+import type { RegistryObserver } from "../../acdc/observing.js";
+import { Unblind } from "../../acdc/unblinding.js";
+import type { KeriDispatchEnvelope } from "../../core/dispatch.js";
+import type { Revery, Router } from "../../core/routing.js";
+import type { Exchanger } from "../exchanges/exchanging.js";
+import type { Hab } from "../identity/habbing.js";
+import type { AuxiliaryQueryProcessor, DispatchDecision } from "../protocol/parsering.js";
+/** Per-identifier DH and Unblind owners behind one query receiver and one reply route each. */
+export declare class IpexAuxiliaries implements AuxiliaryQueryProcessor {
+    private readonly exc;
+    private readonly registry;
+    private readonly rvy;
+    private readonly now;
+    /** Whether the runtime's KRAM is on; DH and Unblind approval need the rows only KRAM writes. */
+    private readonly kram;
+    /** Unused: `claims` decides which queries this receiver takes. */
+    readonly resource = "/ipex";
+    private readonly dhkes;
+    private readonly unblinds;
+    /**
+     * @param exc Exchanger shared by every owner.
+     * @param registry Public registry observer shared by every owner.
+     * @param rvy Reply verifier whose router the owners' routes are registered on.
+     * @param now Receiver clock shared by every owner.
+     * @param kram Whether KRAM is enabled; with it off, `approve` of either owner throws.
+     */
+    constructor(exc: Exchanger, registry: RegistryObserver, rvy: Revery, now: () => number, 
+    /** Whether the runtime's KRAM is on; DH and Unblind approval need the rows only KRAM writes. */
+    kram: boolean);
+    private restored;
+    /** Every live DH owner, for hosts draining their completion cues. */
+    dhkeOwners(): IterableIterator<Dhke>;
+    /** Every live Unblind owner, for hosts delivering the replies they owe. */
+    unblindOwners(): IterableIterator<Unblind>;
+    /** Register the DH and Unblind reply routes once; owners are looked up on each reply. */
+    registerReplyRoutes(rtr: Router): void;
+    /** The DH owner for `hab`, created on first use and recreated when `hab` is no longer the owner's object. */
+    dhke(hab: Hab): Dhke;
+    /** The Unblind owner for `hab`, created on first use and recreated when `hab` is no longer the owner's object. */
+    unblind(hab: Hab): Unblind;
+    /** Close and unregister both owners of `pre`; process-local approvals and retries are cleared. */
+    release(pre: string): void;
+    /** Close every owner; the runtime calls this on explicit close and scope exit. */
+    close(): void;
+    claims(serder: SerderKERI): boolean;
+    processQuery(envelope: KeriDispatchEnvelope): DispatchDecision;
+    private reply;
+    private select;
+    /**
+     * The owner of the one local identifier party to the transaction, created now if needed; absent or
+     * ambiguous means unowned. Parties come from live owners (approved operations) and from the store.
+     */
+    private claimant;
+}
+//# sourceMappingURL=ipex-auxiliaries.d.ts.map

package/types/app/runtime/ipex-auxiliaries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ipex-auxiliaries.d.ts","sourceRoot":"","sources":["../../../src/app/runtime/ipex-auxiliaries.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAC5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAEnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAElD,OAAO,KAAK,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAM1F,+FAA+F;AAC/F,qBAAa,eAAgB,YAAW,uBAAuB;IAc3D,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,gGAAgG;IAChG,OAAO,CAAC,QAAQ,CAAC,IAAI;IAlBvB,kEAAkE;IAClE,QAAQ,CAAC,QAAQ,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA2B;IACjD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8B;IAEvD;;;;;;OAMG;gBAEgB,GAAG,EAAE,SAAS,EACd,QAAQ,EAAE,gBAAgB,EAC1B,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,MAAM;IAClC,gGAAgG;IAC/E,IAAI,EAAE,OAAO;IAGhC,OAAO,CAAC,QAAQ,CAAS;IAEzB,qEAAqE;IACrE,UAAU,IAAI,gBAAgB,CAAC,IAAI,CAAC;IAIpC,2EAA2E;IAC3E,aAAa,IAAI,gBAAgB,CAAC,OAAO,CAAC;IAkB1C,yFAAyF;IACzF,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAKtC,6GAA6G;IAC7G,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI;IAgBpB,kHAAkH;IAClH,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO;IAS1B,kGAAkG;IAClG,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAQ1B,kFAAkF;IAClF,KAAK,IAAI,IAAI;IAMb,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO;IAInC,YAAY,CAAC,QAAQ,EAAE,oBAAoB,GAAG,gBAAgB;IAI9D,OAAO,CAAC,KAAK;IAMb,OAAO,CAAC,MAAM;IAKd;;;OAGG;IACH,OAAO,CAAC,QAAQ;CAgCjB"}

package/types/app/runtime/operation-owners.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Composition and loop of the runtime's operations owners.
+ *
+ * The runtime owns one `IssuanceOperations`, one
+ * `PresentationOperations` and one `UnblindingOperations`, each an in-memory live table
+ * with status derived from the protocol stores, and,
+ * when it has a registry root owner, one `RootReplicator`. `runAgentRuntime` runs each
+ * owner's `processOnce` on one fiber with an adaptive cadence ({@link operationOwnersDo}). The owners
+ * act only for operations a user began or copies already owed.
+ *
+ * The root replicator is a runtime reaction. It derives what is owed from state and records
+ * sent copies in the Baser (`rrsn.`), so a CLI command that sends copies through its own
+ * replicator shares that record with the loop and a later pass does not repeat its sends.
+ */
+import { type Operation } from "effection";
+import { type DerivedUpdateStore } from "../../acdc/custody.js";
+import type { Regery } from "../../acdc/registraring.js";
+import type { RegistryRoot } from "../../acdc/salting.js";
+import { RootReplicator } from "../credentials/root-replicator.js";
+import type { Poster } from "../delivery/forwarding.js";
+import type { Exchanger } from "../exchanges/exchanging.js";
+import type { Habery } from "../identity/habbing.js";
+import { GroupIpexOperations } from "../ipex/group-ipex.js";
+import type { CredentialViews } from "../ipex/ipex-discloser.js";
+import { IssuanceOperations } from "../ipex/issuance.js";
+import { PresentationOperations } from "../ipex/presenting.js";
+import { UnblindingOperations } from "../ipex/unblinding-workflow.js";
+import type { Counselor } from "../multisig/counseling.js";
+import type { Multiplexor } from "../multisig/grouping.js";
+import type { ProtocolProcessor } from "../protocol/protocol-processing.js";
+import type { Reactor } from "../protocol/reactor.js";
+import type { Receiptor } from "../witness/receipting.js";
+import { type DoerPacing } from "./doing.js";
+import type { IpexAuxiliaries } from "./ipex-auxiliaries.js";
+import type { RetryPolicy } from "./retry-backoff.js";
+import type { RuntimeClock } from "./runtime-clock.js";
+import type { ChangeSink } from "./workflow-contract.js";
+/** Milliseconds between owner passes; the cadence of the CLI drivers the loop replaced. */
+export declare const OWNER_TOCK_MS = 50;
+/** Tocks between the replicator's full rotation checks: 1200 tocks of 50 ms is a minute. */
+export declare const OWNER_SWEEP_TOCKS = 1200;
+/** The production pacing of the owner loop. */
+export declare const OWNER_PACING: Readonly<DoerPacing>;
+/**
+ * What an embedder may supply; every field is optional. The operation tables are in memory and their status is
+ * derived from the protocol stores, so there is no store port for them.
+ */
+export interface OperationStores {
+    /**
+     * Non-secret blind-derivation coordinates for issuance and derived presentation. Defaults to
+     * {@link BaserDerivedUpdateStore} over the registry environment's database, which is durable wherever the
+     * registry store is; a wallet with its own table supplies that instead.
+     */
+    derived?: DerivedUpdateStore;
+    /** The embedder's credential inventory, from which presentation selects issued and held credentials. Without it only replies and `apply` can be presented. */
+    views?: CredentialViews;
+    /** Receives identity-only changes after commit; defaults to the runtime's Signaler when it has one. */
+    changes?: ChangeSink;
+}
+/** The operations owners of one runtime, additive on `AgentRuntime.operations`. */
+export interface RuntimeOperations {
+    readonly issuance: IssuanceOperations;
+    /** A local group's v2 IPEX messages (its Admit): propose, approve, status, wait. */
+    readonly groupIpex: GroupIpexOperations;
+    readonly presentation: PresentationOperations;
+    readonly unblinding: UnblindingOperations;
+    /** What the owner loop could not do; read by a host that reports runtime health. */
+    readonly health: OwnerHealth;
+}
+/** The last failure of an owner pass that no single operation owned, and how many there have been. */
+export interface OwnerFault {
+    owner: "issuance" | "groupIpex" | "presentation" | "unblinding" | "replicator";
+    error: string;
+    /** ISO 8601 time of the failure on the host clock. */
+    at: string;
+}
+/**
+ * Failures of the owner loop itself. A failure of one operation (a delivery that throws, an unreadable stored
+ * Grant) ends that operation as `failed` and is never recorded here; this records only what escaped an owner
+ * pass, which the loop survives so that the other owners keep running. `faults` counts them and `last` keeps
+ * the latest. Nothing clears it: a host reads it and decides.
+ */
+export declare class OwnerHealth {
+    faults: number;
+    last: OwnerFault | null;
+}
+/** What the runtime composes for its operations owners. */
+export interface ComposedOwners {
+    operations: RuntimeOperations;
+    rootReplicator: RootReplicator | null;
+}
+/** The runtime pieces the owners borrow; no AgentRuntime bundle. */
+export interface OwnerParts {
+    hby: Habery;
+    acdc: Regery;
+    exc: Exchanger;
+    protocol: ProtocolProcessor;
+    reactor: Reactor;
+    postman: Poster;
+    receiptor: Receiptor;
+    ipex: IpexAuxiliaries;
+    clock: RuntimeClock;
+    registryRoot: RegistryRoot | null;
+    /** Delegates the DH wrappers of group issuance; one owner per runtime registers. */
+    mux: Multiplexor;
+    /** Counsels the group anchor of a custodian's registry update. */
+    counselor: Counselor;
+    /** Delivery retry delays of the owners; the production policy when absent. */
+    retry?: Readonly<RetryPolicy>;
+    /** Milliseconds between issuer query resends; one second when absent. */
+    queryResendMs?: number;
+    changes?: ChangeSink;
+}
+/** Construct the owners over their in-memory tables; the derivation store defaults to the registry database. */
+export declare function composeOwners(parts: OwnerParts, stores?: OperationStores): ComposedOwners;
+/** What the owner loop runs: the owners, the replicator, the DH owners whose completion cues prompt it, the clock. */
+export interface OwnerLoopParts extends ComposedOwners {
+    ipex: IpexAuxiliaries;
+    clock: RuntimeClock;
+}
+/**
+ * Run every owner on one fiber until halted, as a fixed-tock doer (`./doing.ts`): each tock runs an owner that
+ * has live work, then the replicator (after prompting it with the live DH owners' `replicated` cues), and then
+ * the loop waits one tock. Work begun between tocks is seen on the next one; nothing wakes the loop early.
+ *
+ * Idle cost, per tock: four constant-time table checks, one in-memory walk of the Unblind owners for an owed
+ * reply, one drain of each DH owner's cue deck, and the replicator's emptiness checks. The replicator's
+ * rotation check (the establishment SAID of each local group, one keyed read per local identifier) runs on
+ * tock 0 and every `pacing.sweepTocks`. No owner reads a protocol store. Only the first pass, once, scans the
+ * pending exchange escrow for resumable Grants.
+ *
+ * A failure that escapes an owner pass is recorded in `operations.health` and the loop keeps running, so
+ * one owner's fault never stops the others. The owners run one after another, so a delivery that does not return holds the others up until it fails or
+ * its Grant deadline passes; operations already bound each delivery by that deadline.
+ */
+export declare function operationOwnersDo(owners: OwnerLoopParts, pacing?: Readonly<DoerPacing>): Operation<never>;
+//# sourceMappingURL=operation-owners.d.ts.map

package/types/app/runtime/operation-owners.d.ts.map

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

package/types/app/runtime/retry-backoff.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Retry state for a transient delivery failure inside a live operation.
+ *
+ * A member that is briefly offline is normal, so an owner keeps the unsent work, waits with a doubling delay and
+ * tries again on a later pass instead of ending the operation at the first error. The owner decides when retrying
+ * stops: an operation with a deadline ends at the deadline, and one without ends once failures have lasted the
+ * bound it states.
+ */
+/** Delay after the first failure; it doubles per consecutive failure up to {@link RETRY_MAX_MS}. */
+export declare const RETRY_BASE_MS = 1000;
+/** Longest delay between attempts. */
+export declare const RETRY_MAX_MS = 30000;
+/** How long failures may last before an owner with no deadline of its own gives up. */
+export declare const RETRY_BOUND_MS = 600000;
+/**
+ * How long a retried action waits: it starts at `baseMs`, doubles per consecutive failure up to `maxMs`, and an
+ * owner that gives up does so once failures have lasted `boundMs`. Owners that never give up ignore the bound.
+ * Milliseconds; a test passes small values.
+ */
+export interface RetryPolicy {
+    baseMs: number;
+    maxMs: number;
+    boundMs: number;
+}
+/** The production delays of delivery retries. */
+export declare const DEFAULT_RETRY_POLICY: Readonly<RetryPolicy>;
+/** Consecutive-failure counter with a next-attempt time; memory only. */
+export declare class RetryBackoff {
+    #private;
+    private readonly policy;
+    /** Consecutive failures since the last success. */
+    attempts: number;
+    /** Time of the first failure of the current run (host clock, ms); 0 when none. */
+    since: number;
+    /** Error of the latest failure. */
+    last: unknown;
+    constructor(policy?: Readonly<RetryPolicy>);
+    /** Host-clock time (ms) of the next attempt. */
+    get next(): number;
+    /** Whether an attempt may be made at `now`. */
+    due(now: number): boolean;
+    /** Record a failure at `now` and schedule the next attempt. */
+    failed(now: number, error: unknown): void;
+    /** Whether failures have lasted at least `boundMs` by `now`. */
+    exhausted(now: number, boundMs: number): boolean;
+    /** Forget failures after a success. */
+    succeeded(): void;
+}
+//# sourceMappingURL=retry-backoff.d.ts.map

package/types/app/runtime/retry-backoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-backoff.d.ts","sourceRoot":"","sources":["../../../src/app/runtime/retry-backoff.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,oGAAoG;AACpG,eAAO,MAAM,aAAa,OAAQ,CAAC;AACnC,sCAAsC;AACtC,eAAO,MAAM,YAAY,QAAS,CAAC;AACnC,uFAAuF;AACvF,eAAO,MAAM,cAAc,SAAU,CAAC;AAEtC;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,iDAAiD;AACjD,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAIrD,CAAC;AAEH,yEAAyE;AACzE,qBAAa,YAAY;;IASX,OAAO,CAAC,QAAQ,CAAC,MAAM;IARnC,mDAAmD;IACnD,QAAQ,SAAK;IACb,kFAAkF;IAClF,KAAK,SAAK;IACV,mCAAmC;IACnC,IAAI,EAAE,OAAO,CAAQ;gBAGQ,MAAM,GAAE,QAAQ,CAAC,WAAW,CAAwB;IAEjF,gDAAgD;IAChD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,+CAA+C;IAC/C,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB,+DAA+D;IAC/D,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAOzC,gEAAgE;IAChE,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO;IAIhD,uCAAuC;IACvC,SAAS,IAAI,IAAI;CAMlB"}

package/types/app/runtime/workflow-contract.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Shared pieces of the library workflow contract.
+ *
+ * Library workflows follow one shape: `begin*` is an explicit operation that
+ * returns after local commit, `*Status` is a pure synchronous read, and
+ * `waitFor*` only observes. A wait never starts runtime workers: a host that
+ * already runs a runtime must not get a second poller and escrow loop. One-shot
+ * hosts such as the CLI run the runtime around the wait themselves
+ * (`cli/common/runtime-workers.ts`). Remote and time-driven outcomes, including
+ * an expired wait, are returned values; only caller-contract, invariant and
+ * infrastructure failures throw.
+ */
+import { type Operation } from "effection";
+import type { Signaler } from "../notifications/signaling.js";
+import { type RuntimeClock } from "./runtime-clock.js";
+/** Workflow families that publish changes. */
+export type WorkflowKind = "oobi" | "query" | "event" | "delegation" | "group" | "issuance" | "ipex" | "presentation" | "unblinding"
+/** A registry root copy was retained; `id` is the registry. */
+ | "root";
+/** Identity of a workflow whose status may have changed; consumers re-read status. */
+export interface WorkflowChange {
+    kind: WorkflowKind;
+    id: string;
+}
+/**
+ * Receiver of change identities. Owners publish after their commit and never
+ * depend on what the sink does with it; a sink must not throw into a workflow.
+ */
+export interface ChangeSink {
+    push(change: WorkflowChange): void;
+}
+/**
+ * Result of a library wait. `settled` means the status reached a terminal or
+ * wanted state; `timed-out` means the budget expired first. Either way `status`
+ * is the status read at return, so a caller never needs a second read to explain
+ * the outcome. `Timed` adds fields to the timed-out arm (default: the budget).
+ */
+export type WaitResult<S, Timed extends object = {
+    timeoutMs: number;
+}> = {
+    readonly outcome: "settled";
+    readonly status: S;
+} | ({
+    readonly outcome: "timed-out";
+    readonly status: S;
+} & Readonly<Timed>);
+/** In-memory sink that records changes in order. */
+export declare class MemoryChangeSink implements ChangeSink {
+    readonly changes: WorkflowChange[];
+    push(change: WorkflowChange): void;
+}
+/**
+ * Back a sink with the host's transient `Signaler`. Publishing needs no polling:
+ * `push` is a synchronous append that collapses repeats of one workflow into a
+ * single signal (collapse key `kind:id`). Delivery is pull-based, though: the
+ * Signaler has no subscriber hook, so the consumer must read `signaler.list()`.
+ * A closed or failing Signaler drops the change instead of throwing: a hint must
+ * never break the workflow that published it.
+ */
+export declare function signalerChangeSink(signaler: Pick<Signaler, "push">): ChangeSink;
+/**
+ * Observe-only wait: poll `done`, yielding to the scheduler between checks,
+ * until it holds or the deadline passes. Starts no worker and has no effects of
+ * its own.
+ *
+ * @param done Synchronous status read; checked before the first yield.
+ * @param pollMs Elapsed milliseconds between checks. Omitted: yield one scheduler turn.
+ * @returns True when `done` held, false when `timeoutMs` elapsed first.
+ */
+export declare function observeUntil(done: () => boolean, { timeoutMs, clock, pollMs }: {
+    timeoutMs: number;
+    clock?: Pick<RuntimeClock, "now">;
+    pollMs?: number;
+}): Operation<boolean>;
+/**
+ * Wait `milliseconds` on the host's clock, so a fake clock drives it and cancellation releases the timer.
+ */
+export declare function waitOnClock(clock: RuntimeClock, milliseconds: number): Operation<void>;
+//# sourceMappingURL=workflow-contract.d.ts.map

package/types/app/runtime/workflow-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-contract.d.ts","sourceRoot":"","sources":["../../../src/app/runtime/workflow-contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAU,KAAK,SAAS,EAAS,MAAM,WAAW,CAAC;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,EAAE,KAAK,YAAY,EAAe,MAAM,oBAAoB,CAAC;AAGpE,8CAA8C;AAC9C,MAAM,MAAM,YAAY,GACpB,MAAM,GACN,OAAO,GACP,OAAO,GACP,YAAY,GACZ,OAAO,GACP,UAAU,GACV,MAAM,GACN,cAAc,GACd,YAAY;AACd,+DAA+D;GAC7D,MAAM,CAAC;AAEX,sFAAsF;AACtF,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,YAAY,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAAC;CACpC;AAED;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,KAAK,SAAS,MAAM,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,IAClE;IAAE,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAA;CAAE,GACnD,CAAC;IAAE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAA;CAAE,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;AAE9E,oDAAoD;AACpD,qBAAa,gBAAiB,YAAW,UAAU;IACjD,QAAQ,CAAC,OAAO,EAAE,cAAc,EAAE,CAAM;IACxC,IAAI,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;CAGnC;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,UAAU,CAU/E;AAED;;;;;;;;GAQG;AACH,wBAAiB,YAAY,CAC3B,IAAI,EAAE,MAAM,OAAO,EACnB,EAAE,SAAS,EAAE,KAAmB,EAAE,MAAM,EAAE,EAAE;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GACA,SAAS,CAAC,OAAO,CAAC,CASpB;AAED;;GAEG;AACH,wBAAiB,WAAW,CAAC,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,CAKvF"}

package/types/app/transport/byte-source.d.ts

@@ -1,4 +1,9 @@
-/** Transport readers. Each operation owns its reader and joins cancellation. */
+/**
+ * Host-neutral transport readers. Each operation owns its reader and joins
+ * cancellation. The local-file reader lives in `file-bytes.ts` because it
+ * needs host file access.
+ */
+/** Cancellation and chunk size for byte-array and file sources. */
 export interface SourceOptions {
     /** Abort reads and release the transport when its operation stops. */
     signal?: AbortSignal;
@@ -22,15 +27,6 @@ export declare function chunkBytes(bytes: Uint8Array, { signal, maxChunkBytes }?
  * @throws Read/cancel/unlock failures, combined when distinct failures occur.
  */
 export declare function streamBytes(stream: ReadableStream<Uint8Array> | null, { signal }?: Pick<SourceOptions, "signal">): AsyncGenerator<Uint8Array>;
-/**
- * Stream a local file with fixed-size owned buffers and close it on break or abort.
- *
- * @param path Local filesystem path opened read-only for this iteration.
- * @param options Optional cancellation and positive read buffer size in bytes; defaults to 65536.
- * @yields Owned buffers up to the selected chunk size until file EOF.
- * @throws Open/read failures or cancellation; the file closes on EOF, break or failure.
- */
-export declare function fileBytes(path: string, { signal, maxChunkBytes }?: SourceOptions): AsyncGenerator<Uint8Array>;
 /**
  * Collect an explicitly finite operation; bulk ingress should consume its source directly.
  *
@@ -38,4 +34,11 @@ export declare function fileBytes(path: string, { signal, maxChunkBytes }?: Sour
  * @returns A contiguous owned array containing all chunks in order.
  */
 export declare function collectBytes(source: AsyncIterable<Uint8Array>): Promise<Uint8Array<ArrayBuffer>>;
+/**
+ * Reject invalid chunk sizes before allocation or opening a file.
+ *
+ * @param limit Requested per-chunk byte count.
+ * @throws RangeError unless the count is a positive safe integer.
+ */
+export declare function checkLimit(limit: number): void;
 //# sourceMappingURL=byte-source.d.ts.map

package/types/app/transport/byte-source.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"byte-source.d.ts","sourceRoot":"","sources":["../../../src/app/transport/byte-source.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAKhF,MAAM,WAAW,aAAa;IAC5B,sEAAsE;IACtE,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,6EAA6E;IAC7E,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;GAMG;AACH,wBAAuB,UAAU,CAC/B,KAAK,EAAE,UAAU,EACjB,EAAE,MAAM,EAAE,aAAyB,EAAE,GAAE,aAAkB,GACxD,cAAc,CAAC,UAAU,CAAC,CAQ5B;AAED;;;;;;;GAOG;AACH,wBAAuB,WAAW,CAChC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,IAAI,EACzC,EAAE,MAAM,EAAE,GAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAM,GAC7C,cAAc,CAAC,UAAU,CAAC,CA4C5B;AAED;;;;;;;GAOG;AACH,wBAAuB,SAAS,CAC9B,IAAI,EAAE,MAAM,EACZ,EAAE,MAAM,EAAE,aAAyB,EAAE,GAAE,aAAkB,GACxD,cAAc,CAAC,UAAU,CAAC,CA0B5B;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAetG"}
+{"version":3,"file":"byte-source.d.ts","sourceRoot":"","sources":["../../../src/app/transport/byte-source.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,mEAAmE;AACnE,MAAM,WAAW,aAAa;IAC5B,sEAAsE;IACtE,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,6EAA6E;IAC7E,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;GAMG;AACH,wBAAuB,UAAU,CAC/B,KAAK,EAAE,UAAU,EACjB,EAAE,MAAM,EAAE,aAAyB,EAAE,GAAE,aAAkB,GACxD,cAAc,CAAC,UAAU,CAAC,CAQ5B;AAED;;;;;;;GAOG;AACH,wBAAuB,WAAW,CAChC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,IAAI,EACzC,EAAE,MAAM,EAAE,GAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAM,GAC7C,cAAc,CAAC,UAAU,CAAC,CA4C5B;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAetG;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAE9C"}

package/types/app/transport/cesr-egress.d.ts

@@ -5,9 +5,13 @@
  * caller consumes that body before leaving the enclosing scope. Neither path
  * implicitly feeds successful response bytes into protocol processing.
  *
- * Match KERIpy's detached-attachment POST contract while retaining the exact
- * signed body. Only the known pre-intake Falcon media refusal permits a second
- * request; authentication/application failures and network errors are not retries.
+ * Match KERIpy HTTPMessenger's two wire shapes. A JSON/CBOR/MGPK frame is one
+ * detached-attachment POST retaining the exact signed body; only the known
+ * pre-intake Falcon media refusal permits a second request, and
+ * authentication/application failures and network errors are not retries.
+ * A native CESR frame (counter-prefixed body, text or binary domain) is one
+ * whole opaque PUT of the serialized frame, as KERIpy sends since PR 1751,
+ * because a native body is not JSON and cannot travel in the detached form.
  */
 import { type CesrFrame } from "cesr-ts";
 import { type Operation } from "effection";
@@ -69,6 +73,16 @@ export declare function readResponseDetail(response: HttpStreamResponse, signal:
  * @throws CesrHttpRefusal for a completed refusal; request, transport and cleanup failures propagate.
  */
 export declare function requestFrame(url: string, frame: CesrFrame, http: HttpClient, options?: EgressOptions): Operation<HttpStreamResponse>;
+/**
+ * Recognize a frame whose body is native CESR rather than a JSON/CBOR/MGPK message.
+ * KERIpy HTTPMessenger decides by sniffing the message cold start for a counter in
+ * either domain; a hydrated native body carries kind CESR and its raw bytes begin
+ * with that fixed-field counter. Opaque fallback bodies without a counter stay ordinary.
+ *
+ * @param frame Parsed frame whose body kind and raw bytes decide the wire shape.
+ * @returns True when the frame must travel as one whole PUT instead of a detached POST.
+ */
+export declare function isNativeCesrFrame(frame: CesrFrame): boolean;
 /**
  * Recognize KERIpy v1's exact preprocessing media refusal, before protocol intake.
  * Attachment framing and the current media type are required. Authentication,
@@ -83,8 +97,8 @@ export declare function requestFrame(url: string, frame: CesrFrame, http: HttpCl
 export declare function isLegacyCesrMediaRejection(request: HttpRequestInit, status: number, detail: string): boolean;
 /**
  * Send a CESR source and throw on a completed peer refusal.
- * One parsed frame becomes one POST, and its request scope closes before the next
- * source pull. A refusal stops the sequence; prior frames may already be delivered.
+ * One parsed frame becomes one request (a detached POST, or one whole PUT for a
+ * native frame), and its request scope closes before the next source pull. A refusal stops the sequence; prior frames may already be delivered.
  * Cancellation aborts active work, joins any pending source pull and returns the
  * parser iterator before leaving. There is no automatic retry beyond media fallback.
  * A pending asynchronous source pull can finish after cancellation is requested;
@@ -101,8 +115,8 @@ export declare function isLegacyCesrMediaRejection(request: HttpRequestInit, sta
 export declare function postCesr(url: string, source: (signal: AbortSignal) => AsyncIterable<Uint8Array>, http: HttpClient, options?: EgressOptions): Operation<void>;
 /**
  * Send frames sequentially and return a completed peer refusal as data.
- * One parsed frame becomes one POST, and its request scope closes before the next
- * source pull. A refusal stops the sequence; prior frames may already be delivered.
+ * One parsed frame becomes one request (a detached POST, or one whole PUT for a
+ * native frame), and its request scope closes before the next source pull. A refusal stops the sequence; prior frames may already be delivered.
  * Cancellation aborts active work, joins any pending source pull and returns the
  * parser iterator before leaving. There is no automatic retry beyond media fallback.
  *

package/types/app/transport/cesr-egress.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cesr-egress.d.ts","sourceRoot":"","sources":["../../../src/app/transport/cesr-egress.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAGL,KAAK,SAAS,EAGf,MAAM,SAAS,CAAC;AACjB,OAAO,EAAgB,KAAK,SAAS,EAA0B,MAAM,WAAW,CAAC;AACjF,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAQvD,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAExF,kGAAkG;AAClG,qBAAa,eAAgB,SAAQ,eAAe;IAOrB,QAAQ,CAAC,MAAM,EAAE,MAAM;IANpD;;;;;OAKG;gBACS,OAAO,EAAE,MAAM,EAAW,MAAM,EAAE,MAAM;CAGrD;AAED,qFAAqF;AACrF,MAAM,MAAM,cAAc,GAAG;IAC3B,kGAAkG;IAClG,IAAI,EAAE,UAAU,CAAC;CAClB,GAAG;IACF,kGAAkG;IAClG,IAAI,EAAE,QAAQ,CAAC;IACf,4EAA4E;IAC5E,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AAgBF,4CAA4C;AAC5C,MAAM,WAAW,aAAa;IAC5B,sGAAsG;IACtG,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,yDAAyD;IACzD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uFAAuF;IACvF,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,kBAAkB,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAQ3G;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAiB,YAAY,CAC3B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,UAAU,EAChB,OAAO,GAAE,aAAkB,GAC1B,SAAS,CAAC,kBAAkB,CAAC,CAI/B;AAiFD;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAc5G;AAqCD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAiB,QAAQ,CACvB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,aAAa,CAAC,UAAU,CAAC,EAC1D,IAAI,EAAE,UAAU,EAChB,OAAO,GAAE,aAAkB,GAC1B,SAAS,CAAC,IAAI,CAAC,CAGjB;AACD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,aAAa,CAAC,UAAU,CAAC,EAC1D,IAAI,EAAE,UAAU,EAChB,OAAO,GAAE,aAAkB,GAC1B,SAAS,CAAC,cAAc,CAAC,CAoE3B"}
+{"version":3,"file":"cesr-egress.d.ts","sourceRoot":"","sources":["../../../src/app/transport/cesr-egress.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAIL,KAAK,SAAS,EAMf,MAAM,SAAS,CAAC;AACjB,OAAO,EAAgB,KAAK,SAAS,EAA0B,MAAM,WAAW,CAAC;AACjF,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AASvD,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAExF,kGAAkG;AAClG,qBAAa,eAAgB,SAAQ,eAAe;IAOrB,QAAQ,CAAC,MAAM,EAAE,MAAM;IANpD;;;;;OAKG;gBACS,OAAO,EAAE,MAAM,EAAW,MAAM,EAAE,MAAM;CAGrD;AAED,qFAAqF;AACrF,MAAM,MAAM,cAAc,GAAG;IAC3B,kGAAkG;IAClG,IAAI,EAAE,UAAU,CAAC;CAClB,GAAG;IACF,kGAAkG;IAClG,IAAI,EAAE,QAAQ,CAAC;IACf,4EAA4E;IAC5E,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AAgBF,4CAA4C;AAC5C,MAAM,WAAW,aAAa;IAC5B,sGAAsG;IACtG,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,yDAAyD;IACzD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uFAAuF;IACvF,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,kBAAkB,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAQ3G;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAiB,YAAY,CAC3B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,UAAU,EAChB,OAAO,GAAE,aAAkB,GAC1B,SAAS,CAAC,kBAAkB,CAAC,CAI/B;AA2CD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAI3D;AAqFD;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAc5G;AAqCD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAiB,QAAQ,CACvB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,aAAa,CAAC,UAAU,CAAC,EAC1D,IAAI,EAAE,UAAU,EAChB,OAAO,GAAE,aAAkB,GAC1B,SAAS,CAAC,IAAI,CAAC,CAGjB;AACD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,aAAa,CAAC,UAAU,CAAC,EAC1D,IAAI,EAAE,UAAU,EAChB,OAAO,GAAE,aAAkB,GAC1B,SAAS,CAAC,cAAc,CAAC,CAoE3B"}

package/types/app/transport/file-bytes.d.ts

@@ -0,0 +1,11 @@
+import { type SourceOptions } from "./byte-source.js";
+/**
+ * Stream a local file with fixed-size owned buffers and close it on break or abort.
+ *
+ * @param path Local filesystem path opened read-only for this iteration.
+ * @param options Optional cancellation and positive read buffer size in bytes; defaults to 65536.
+ * @yields Owned buffers up to the selected chunk size until file EOF.
+ * @throws Open/read failures or cancellation; the file closes on EOF, break or failure.
+ */
+export declare function fileBytes(path: string, { signal, maxChunkBytes }?: SourceOptions): AsyncGenerator<Uint8Array>;
+//# sourceMappingURL=file-bytes.d.ts.map

package/types/app/transport/file-bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-bytes.d.ts","sourceRoot":"","sources":["../../../src/app/transport/file-bytes.ts"],"names":[],"mappings":"AAIA,OAAO,EAAc,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAElE;;;;;;;GAOG;AACH,wBAAuB,SAAS,CAC9B,IAAI,EAAE,MAAM,EACZ,EAAE,MAAM,EAAE,aAAyB,EAAE,GAAE,aAAkB,GACxD,cAAc,CAAC,UAAU,CAAC,CA0B5B"}

package/types/app/transport/http-client.d.ts

@@ -1,5 +1,6 @@
 /** Native HTTP request construction, byte I/O and joined attempt cleanup. */
 import { type Operation } from "effection";
+import type { TcpDialer } from "./tcp-dialer.js";
 /** Existing HTTP request choices; protocol framing and retry policy belong to callers. */
 export interface HttpRequestInit {
     /** HTTP method, validated by Request before any network execution. */
@@ -44,6 +45,8 @@ export interface HttpStreamResponse {
 }
 /** A scoped HTTP implementation supplied by composition, with an explicit transport-error contract. */
 export interface HttpClient {
+    /** Host-supplied TCP dialing; absent where the host has no TCP, such as browsers. */
+    readonly tcp?: TcpDialer;
     /**
      * Return finite response bytes after the owned request scope has closed.
      *

package/types/app/transport/http-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-client.d.ts","sourceRoot":"","sources":["../../../src/app/transport/http-client.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,OAAO,EAAQ,KAAK,SAAS,EAAoB,MAAM,WAAW,CAAC;AAMnE,0FAA0F;AAC1F,MAAM,WAAW,eAAe;IAC9B,sEAAsE;IACtE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qFAAqF;IACrF,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,yFAAyF;IACzF,IAAI,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,IAAI,CAAC;IAChD,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,6EAA6E;IAC7E,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;CAC7B;AAED,uFAAuF;AACvF,MAAM,WAAW,YAAY;IAC3B,qEAAqE;IACrE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,qFAAqF;IACrF,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,kCAAkC;IAClC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;CAC3B;AAED,gGAAgG;AAChG,MAAM,WAAW,kBAAkB;IACjC,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,qFAAqF;IACrF,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,oEAAoE;IACpE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B;;;;;;;OAOG;IACH,IAAI,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC;CACvD;AAED,uGAAuG;AACvG,MAAM,WAAW,UAAU;IACzB;;;;;;;OAOG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC,YAAY,CAAC,CAAC;IACtE;;;;;;;;;;OAUG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC,kBAAkB,CAAC,CAAC;CAC1E;AAED;;;;;;GAMG;AACH,qBAAa,eAAgB,YAAW,UAAU;IAChD;;;;;;;OAOG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,eAAoB,GAAG,SAAS,CAAC,YAAY,CAAC;IASzE;;;;;;;;;;OAUG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,eAAoB,GAAG,SAAS,CAAC,kBAAkB,CAAC;CAsH7E"}
+{"version":3,"file":"http-client.d.ts","sourceRoot":"","sources":["../../../src/app/transport/http-client.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,OAAO,EAAQ,KAAK,SAAS,EAAoB,MAAM,WAAW,CAAC;AAInE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGjD,0FAA0F;AAC1F,MAAM,WAAW,eAAe;IAC9B,sEAAsE;IACtE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qFAAqF;IACrF,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,yFAAyF;IACzF,IAAI,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,IAAI,CAAC;IAChD,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,6EAA6E;IAC7E,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;CAC7B;AAED,uFAAuF;AACvF,MAAM,WAAW,YAAY;IAC3B,qEAAqE;IACrE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,qFAAqF;IACrF,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,kCAAkC;IAClC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;CAC3B;AAED,gGAAgG;AAChG,MAAM,WAAW,kBAAkB;IACjC,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,qFAAqF;IACrF,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,oEAAoE;IACpE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B;;;;;;;OAOG;IACH,IAAI,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC;CACvD;AAED,uGAAuG;AACvG,MAAM,WAAW,UAAU;IACzB,qFAAqF;IACrF,QAAQ,CAAC,GAAG,CAAC,EAAE,SAAS,CAAC;IAEzB;;;;;;;OAOG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC,YAAY,CAAC,CAAC;IACtE;;;;;;;;;;OAUG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC,kBAAkB,CAAC,CAAC;CAC1E;AAmBD;;;;;;GAMG;AACH,qBAAa,eAAgB,YAAW,UAAU;IAChD;;;;;;;OAOG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,eAAoB,GAAG,SAAS,CAAC,YAAY,CAAC;IASzE;;;;;;;;;;OAUG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,eAAoB,GAAG,SAAS,CAAC,kBAAkB,CAAC;CAyH7E"}

package/types/app/transport/http-messenger.d.ts

@@ -1,19 +1,22 @@
-/** Ordinary signed-message POST delivery, independent of query receive processing. */
+/** Ordinary signed-message HTTP delivery, independent of query receive processing. */
 import type { Operation } from "effection";
 import { type CesrPostResult, type EgressOptions } from "./cesr-egress.js";
 import type { HttpClient } from "./http-client.js";
 /** Fixed request metadata; transport construction does not select a framing preference. */
 export type HTTPMessengerOptions = Pick<EgressOptions, "destination" | "headers">;
 /**
- * Send ordinary signed messages as ordered HTTP POSTs and finish response cleanup.
+ * Send ordinary signed messages as ordered HTTP requests and finish response cleanup.
  * Producers own preparation and Poster owns queued work. This component needs no
  * Habery, protocol processor, parser state, timer or response history.
  *
- * Corresponds to the ordinary POST role of KERIpy HTTPMessenger. Complete CESR
- * frames become separate POSTs: original signed body in the request body, text
- * attachments in CESR-ATTACHMENT. Only the recognized pre-intake media refusal
- * permits a second attempt with legacy media metadata. Successful response bytes
- * are drained and discarded; protocol receiving belongs to independent intake.
+ * Corresponds to KERIpy HTTPMessenger. Each complete CESR frame is one request,
+ * shaped by its body: a JSON/CBOR/MGPK frame is a POST with the original signed
+ * body in the request body and text attachments in CESR-ATTACHMENT, where only
+ * the recognized pre-intake media refusal permits a second attempt with legacy
+ * media metadata; a native CESR frame (counter-prefixed body) is one whole PUT of
+ * the serialized frame with Content-Length and CESR-DESTINATION, matching KERIpy
+ * since PR 1751 and without detached headers or media fallback. Successful response
+ * bytes are drained and discarded; protocol receiving belongs to independent intake.
  */
 export declare class HTTPMessenger {
     readonly url: string;
@@ -28,9 +31,11 @@ export declare class HTTPMessenger {
      */
     send(msg: Uint8Array, options?: Pick<EgressOptions, "signal">): Operation<CesrPostResult>;
     /**
-     * Iterate ordinary messages into POSTs; this is not whole-stream PUT delivery.
-     * A later malformed message cannot prevent an earlier valid POST. Parser,
-     * transport, source and cleanup failures propagate; HTTP refusal is typed data.
+     * Iterate messages into one request each; this is not whole-stream PUT delivery.
+     * A multi-message native stream becomes successive per-frame PUTs, not KERIpy's
+     * single bulk PUT. A later malformed message cannot prevent an earlier valid
+     * request. Parser, transport, source and cleanup failures propagate; HTTP
+     * refusal is typed data.
      */
     sendSource(source: (signal: AbortSignal) => AsyncIterable<Uint8Array>, options?: Pick<EgressOptions, "signal">): Operation<CesrPostResult>;
 }

package/types/app/transport/http-messenger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-messenger.d.ts","sourceRoot":"","sources":["../../../src/app/transport/http-messenger.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,EAAmB,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC5F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,2FAA2F;AAC3F,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,aAAa,EAAE,aAAa,GAAG,SAAS,CAAC,CAAC;AAElF;;;;;;;;;;GAUG;AACH,qBAAa,aAAa;IAGtB,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,4EAA4E;gBAEjE,GAAG,EAAE,MAAM,EACH,IAAI,EAAE,UAAU,EAChB,OAAO,GAAE,oBAAyB;IAGrD;;;;OAIG;IACH,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,OAAO,GAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAM,GAAG,SAAS,CAAC,cAAc,CAAC;IAI7F;;;;OAIG;IACH,UAAU,CACR,MAAM,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,aAAa,CAAC,UAAU,CAAC,EAC1D,OAAO,GAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAM,GAC1C,SAAS,CAAC,cAAc,CAAC;CAG7B"}
+{"version":3,"file":"http-messenger.d.ts","sourceRoot":"","sources":["../../../src/app/transport/http-messenger.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,EAAmB,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC5F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,2FAA2F;AAC3F,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,aAAa,EAAE,aAAa,GAAG,SAAS,CAAC,CAAC;AAElF;;;;;;;;;;;;;GAaG;AACH,qBAAa,aAAa;IAGtB,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,4EAA4E;gBAEjE,GAAG,EAAE,MAAM,EACH,IAAI,EAAE,UAAU,EAChB,OAAO,GAAE,oBAAyB;IAGrD;;;;OAIG;IACH,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,OAAO,GAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAM,GAAG,SAAS,CAAC,cAAc,CAAC;IAI7F;;;;;;OAMG;IACH,UAAU,CACR,MAAM,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,aAAa,CAAC,UAAU,CAAC,EAC1D,OAAO,GAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAM,GAC1C,SAAS,CAAC,cAAc,CAAC;CAG7B"}

package/types/app/transport/message-source.d.ts

@@ -16,7 +16,7 @@ export interface IngressOptions extends DispatchOptions {
  * @param protocol Borrowed dispatcher over synchronous domain commits and correlated cue publication.
  * @param kvy Input-owned KEL processor bound to the same store, reply verifier and cue flow.
  * @param options Dispatch policy and optional upstream cancellation; defaults follow the shared processor.
- * @throws Parsing, dispatch and cleanup failures propagate after the pending pull and iterator cleanup join.
+ * @throws Parsing, infrastructure dispatch and cleanup failures propagate after the pending pull and iterator cleanup join; one invalid message does not.
  */
 export declare function processMessages(source: (signal: AbortSignal) => AsyncIterable<Uint8Array>, protocol: ProtocolProcessor, kvy: Kevery, options?: IngressOptions): Operation<void>;
 //# sourceMappingURL=message-source.d.ts.map

package/types/app/transport/messengering.d.ts

@@ -2,8 +2,8 @@ import type { RuntimeClock } from "../runtime/runtime-clock.js";
 import type { HttpClient } from "./http-client.js";
 import { HTTPMessenger } from "./http-messenger.js";
 import { HTTPStreamMessenger } from "./http-stream-messenger.js";
-import { TCPMessenger } from "./tcp-messenger.js";
-import { TCPStreamMessenger } from "./tcp-stream-messenger.js";
+import type { TCPMessenger } from "./tcp-messenger.js";
+import type { TCPStreamMessenger } from "./tcp-stream-messenger.js";
 /** Resolved transport URLs; identity/role discovery belongs to the caller. */
 export interface MessengerUrls {
     https?: string;

package/types/app/transport/messengering.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messengering.d.ts","sourceRoot":"","sources":["../../../src/app/transport/messengering.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAE/D,8EAA8E;AAC9E,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAmBD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAC3B,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,YAAY,EACnB,OAAO,CAAC,EAAE,WAAW,GACpB,aAAa,GAAG,YAAY,CAI9B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,UAAU,EACnB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,YAAY,EACnB,OAAO,CAAC,EAAE,WAAW,GACpB,mBAAmB,GAAG,kBAAkB,CAI1C"}
+{"version":3,"file":"messengering.d.ts","sourceRoot":"","sources":["../../../src/app/transport/messengering.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,8EAA8E;AAC9E,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAmBD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAC3B,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,YAAY,EACnB,OAAO,CAAC,EAAE,WAAW,GACpB,aAAa,GAAG,YAAY,CAI9B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,UAAU,EACnB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,YAAY,EACnB,OAAO,CAAC,EAAE,WAAW,GACpB,mBAAmB,GAAG,kBAAkB,CAI1C"}

package/types/app/transport/node-http-client.d.ts

@@ -0,0 +1,10 @@
+/** HTTP client plus TCP egress, for hosts with sockets. */
+import { FetchHttpClient } from "./http-client.js";
+import type { TcpDialer } from "./tcp-dialer.js";
+/** Dials TCP endpoints through `node:net`. */
+export declare const nodeTcpDialer: TcpDialer;
+/** A `FetchHttpClient` that can also reach `tcp:` endpoints. */
+export declare class NodeHttpClient extends FetchHttpClient {
+    readonly tcp: TcpDialer;
+}
+//# sourceMappingURL=node-http-client.d.ts.map