@aria-cli/tools 1.0.10 → 1.0.12

package/dist-cjs/network-runtime/address-types.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DurableSubmitResultSchema = exports.DurableDeliveryResultSchema = exports.DurableDeliveryHandleSchema = exports.LocalRuntimeSummarySchema = exports.NodeAdvertisementSchema = exports.ControlEndpointAdvertisementSchema = exports.InboxAddressSchema = exports.TransportEndpointAdvertisementSchema = exports.SigningPublicKeySchema = exports.LoopbackTlsIdentitySchema = exports.TlsCaFingerprintSchema = exports.PeerTransportIdSchema = exports.PrincipalFingerprintSchema = exports.ClientIdSchema = exports.RuntimeOwnerRecordSchema = exports.DeliveryLifecycleRevisionSchema = exports.OwnerGenerationSchema = exports.RevocationDecisionSchema = exports.RevocationOperatorConfirmationSchema = exports.RevocationGenerationSchema = exports.BindingGenerationSchema = exports.EndpointRevisionSchema = exports.PublicationRevisionSchema = exports.NodeMetadataSchema = exports.RuntimeIdSchema = exports.NodeIdSchema = void 0;
+const zod_1 = require("zod");
+const NonEmptyStringSchema = zod_1.z.string().trim().min(1);
+/**
+ * Stable durable identity for a node.
+ * Semantic rules are enforced by the runtime cutover plan; the contract layer
+ * starts by making the shape canonical everywhere.
+ */
+exports.NodeIdSchema = NonEmptyStringSchema.brand();
+/** One boot of a given node runtime. */
+exports.RuntimeIdSchema = NonEmptyStringSchema.brand();
+exports.NodeMetadataSchema = zod_1.z.object({
+    nodeId: exports.NodeIdSchema,
+    createdAt: NonEmptyStringSchema,
+    schemaVersion: zod_1.z.number().int().positive(),
+    migratedFromLegacy: zod_1.z.boolean(),
+});
+/** Monotonic publication revision for externally visible runtime advertisements. */
+exports.PublicationRevisionSchema = zod_1.z.number().int().nonnegative();
+/** Monotonic endpoint revision for register/discovery refreshes. */
+exports.EndpointRevisionSchema = zod_1.z.number().int().nonnegative();
+/** Monotonic generation for peer-binding continuity transitions. */
+exports.BindingGenerationSchema = zod_1.z.number().int().nonnegative();
+/** Monotonic generation for revocation precedence and continuity conflict checks. */
+exports.RevocationGenerationSchema = zod_1.z.number().int().nonnegative();
+/** How a local operator confirmed a revocation decision. */
+exports.RevocationOperatorConfirmationSchema = zod_1.z.enum([
+    "local_operator_confirmed",
+    "remote_capability_authenticated",
+]);
+/** Structured local authority record for a peer revocation decision. */
+exports.RevocationDecisionSchema = zod_1.z.object({
+    localNodeId: exports.NodeIdSchema,
+    targetNodeId: exports.NodeIdSchema,
+    revocationGeneration: exports.RevocationGenerationSchema,
+    operatorConfirmation: exports.RevocationOperatorConfirmationSchema,
+});
+/** Monotonic owner generation for runtime ownership records. */
+exports.OwnerGenerationSchema = zod_1.z.number().int().positive();
+/** Monotonic revision for durable delivery lifecycle state transitions. */
+exports.DeliveryLifecycleRevisionSchema = zod_1.z.number().int().nonnegative();
+exports.RuntimeOwnerRecordSchema = zod_1.z
+    .object({
+    schemaVersion: zod_1.z.number().int().positive(),
+    nodeId: exports.NodeIdSchema,
+    ariaHome: NonEmptyStringSchema,
+    runtimePid: zod_1.z.number().int().positive(),
+    runtimeId: exports.RuntimeIdSchema,
+    displayNameSnapshot: NonEmptyStringSchema.optional(),
+    runtimeSocket: NonEmptyStringSchema,
+    startedAt: NonEmptyStringSchema,
+    lastHeartbeat: NonEmptyStringSchema,
+    ownerGeneration: exports.OwnerGenerationSchema,
+})
+    .strict();
+/** One attached local client of the runtime. */
+exports.ClientIdSchema = NonEmptyStringSchema.brand();
+/** Durable principal fingerprint (SHA-256 hex of signing public key DER). Signing-key evidence only. */
+exports.PrincipalFingerprintSchema = NonEmptyStringSchema.brand();
+/** Transport public key / transport identity for a peer. */
+exports.PeerTransportIdSchema = NonEmptyStringSchema.brand();
+/** TLS CA certificate fingerprint (SHA-256 hex of CA cert DER). Certificate-authority evidence only — distinct from signing-key evidence. */
+exports.TlsCaFingerprintSchema = NonEmptyStringSchema.brand();
+/** Local-only loopback TLS SAN identity used for same-machine control attachment. */
+exports.LoopbackTlsIdentitySchema = NonEmptyStringSchema.brand();
+/** Base64-encoded signing public key material crossing runtime/shared boundaries. */
+exports.SigningPublicKeySchema = NonEmptyStringSchema.brand();
+/** Explicit network transport endpoint advertisement. */
+exports.TransportEndpointAdvertisementSchema = zod_1.z.object({
+    host: NonEmptyStringSchema,
+    port: zod_1.z.number().int().min(1).max(65535),
+});
+/**
+ * Runtime-owned local inbox addressing.
+ * Same-machine clients are local attachments, not mesh peers.
+ */
+exports.InboxAddressSchema = zod_1.z.discriminatedUnion("kind", [
+    zod_1.z.object({
+        kind: zod_1.z.literal("node"),
+        nodeId: exports.NodeIdSchema,
+    }),
+    zod_1.z.object({
+        kind: zod_1.z.literal("client"),
+        clientId: exports.ClientIdSchema,
+    }),
+]);
+/**
+ * Public control-plane endpoint advertisement used by peers for pinned,
+ * mutating requests.
+ */
+exports.ControlEndpointAdvertisementSchema = zod_1.z.object({
+    host: NonEmptyStringSchema,
+    port: zod_1.z.number().int().min(1).max(65535),
+    tlsCaFingerprint: exports.TlsCaFingerprintSchema,
+    tlsServerIdentity: exports.PrincipalFingerprintSchema,
+    protocolVersion: zod_1.z.number().int().positive(),
+    endpointRevision: exports.EndpointRevisionSchema.optional(),
+});
+/**
+ * Remote/public node advertisement. This deliberately excludes local-only
+ * runtime/session identity like RuntimeId.
+ */
+exports.NodeAdvertisementSchema = zod_1.z.object({
+    nodeId: exports.NodeIdSchema,
+    principalFingerprint: exports.PrincipalFingerprintSchema,
+    transportPublicKey: exports.PeerTransportIdSchema,
+    publicationRevision: exports.PublicationRevisionSchema.optional(),
+    controlEndpoint: exports.ControlEndpointAdvertisementSchema.optional(),
+    displayNameSnapshot: NonEmptyStringSchema.optional(),
+});
+/**
+ * Local-only runtime registry summary. This is not a remote/public mesh
+ * contract and may include RuntimeId.
+ */
+exports.LocalRuntimeSummarySchema = zod_1.z.object({
+    nodeId: exports.NodeIdSchema,
+    runtimeId: exports.RuntimeIdSchema,
+    lastHeartbeat: NonEmptyStringSchema.optional(),
+    controlEndpoint: exports.ControlEndpointAdvertisementSchema.optional(),
+    displayNameSnapshot: NonEmptyStringSchema.optional(),
+});
+// ── Durable Delivery Handle ────────────────────────────────────────
+/**
+ * Branded operation handle for durable delivery.
+ * Produced ONLY by `submitDurable()` — the caller never mints handles.
+ */
+exports.DurableDeliveryHandleSchema = NonEmptyStringSchema.brand();
+/**
+ * Terminal status types for a durable delivery operation.
+ */
+exports.DurableDeliveryResultSchema = zod_1.z.discriminatedUnion("status", [
+    zod_1.z.object({
+        status: zod_1.z.literal("pending"),
+        queuedAt: zod_1.z.string(),
+        nextAttemptAt: zod_1.z.string().optional(),
+        attemptCount: zod_1.z.number(),
+    }),
+    zod_1.z.object({
+        status: zod_1.z.literal("delivered"),
+        deliveredAt: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        status: zod_1.z.literal("expired"),
+        reason: zod_1.z.literal("ttl_exceeded"),
+        queuedAt: zod_1.z.string(),
+        expiredAt: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        status: zod_1.z.literal("rejected"),
+        reason: zod_1.z.enum(["recipient_revoked", "recipient_unknown", "envelope_invalid"]),
+    }),
+]);
+/**
+ * Submit result — returned immediately from `submitDurable()`.
+ */
+exports.DurableSubmitResultSchema = zod_1.z.discriminatedUnion("status", [
+    zod_1.z.object({
+        status: zod_1.z.literal("accepted"),
+        operationId: exports.DurableDeliveryHandleSchema,
+        queuedAt: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        status: zod_1.z.literal("rejected"),
+        reason: zod_1.z.enum(["recipient_revoked", "recipient_unknown", "envelope_invalid"]),
+    }),
+]);

package/dist-cjs/network-runtime/db-owner-fencing.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Shared database-level ownership fencing for runtime-owned durable stores.
+ *
+ * All stores backed by the same SQLite database share one `owner_epoch` table.
+ * The runtime claims the epoch once at startup. Each store's write methods
+ * call `assertDbOwnership()` before durable mutations.
+ *
+ * A zombie runtime whose generation is stale gets StaleOwnerError on
+ * its next write — no external kill needed.
+ */
+interface SqliteStatementLike {
+    run(...params: unknown[]): {
+        changes: number;
+    };
+    get(...params: unknown[]): unknown;
+}
+export interface OwnerEpochDb {
+    exec(sql: string): unknown;
+    prepare(sql: string): SqliteStatementLike;
+}
+export declare class StaleOwnerError extends Error {
+    readonly kind: "StaleOwnerError";
+    readonly claimedGeneration: number;
+    readonly currentGeneration: number;
+    constructor(claimed: number, current: number);
+}
+/**
+ * Ensure the owner_epoch table exists in the given database.
+ * Safe to call multiple times (idempotent).
+ */
+export declare function ensureOwnerEpochTable(db: OwnerEpochDb): void;
+/**
+ * Atomically claim the owner epoch for this runtime.
+ * Throws StaleOwnerError if a newer generation already owns the database.
+ */
+export declare function claimDbOwnerEpoch(db: OwnerEpochDb, generation: number): void;
+/**
+ * Assert the calling runtime is still the current owner of this database.
+ * Must be called inside the same SQLite transaction as the write.
+ * Throws StaleOwnerError if superseded.
+ */
+export declare function assertDbOwnership(db: OwnerEpochDb, generation: number): void;
+export {};

package/dist-cjs/network-runtime/db-owner-fencing.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Shared database-level ownership fencing for runtime-owned durable stores.
+ *
+ * All stores backed by the same SQLite database share one `owner_epoch` table.
+ * The runtime claims the epoch once at startup. Each store's write methods
+ * call `assertDbOwnership()` before durable mutations.
+ *
+ * A zombie runtime whose generation is stale gets StaleOwnerError on
+ * its next write — no external kill needed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaleOwnerError = void 0;
+exports.ensureOwnerEpochTable = ensureOwnerEpochTable;
+exports.claimDbOwnerEpoch = claimDbOwnerEpoch;
+exports.assertDbOwnership = assertDbOwnership;
+class StaleOwnerError extends Error {
+    kind = "StaleOwnerError";
+    claimedGeneration;
+    currentGeneration;
+    constructor(claimed, current) {
+        super(`StaleOwnerError: runtime claims generation ${claimed} but store is at generation ${current}. ` +
+            `This runtime has been superseded and must shut down immediately.`);
+        this.name = "StaleOwnerError";
+        this.claimedGeneration = claimed;
+        this.currentGeneration = current;
+    }
+}
+exports.StaleOwnerError = StaleOwnerError;
+/**
+ * Ensure the owner_epoch table exists in the given database.
+ * Safe to call multiple times (idempotent).
+ */
+function ensureOwnerEpochTable(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS owner_epoch (
+      scope TEXT PRIMARY KEY DEFAULT 'runtime',
+      owner_generation INTEGER NOT NULL
+    )
+  `);
+}
+/**
+ * Atomically claim the owner epoch for this runtime.
+ * Throws StaleOwnerError if a newer generation already owns the database.
+ */
+function claimDbOwnerEpoch(db, generation) {
+    ensureOwnerEpochTable(db);
+    const result = db
+        .prepare(`INSERT INTO owner_epoch (scope, owner_generation) VALUES ('runtime', ?)
+       ON CONFLICT(scope) DO UPDATE SET owner_generation = excluded.owner_generation
+       WHERE excluded.owner_generation > owner_epoch.owner_generation`)
+        .run(generation);
+    if (result.changes === 0) {
+        const row = db
+            .prepare("SELECT owner_generation FROM owner_epoch WHERE scope = 'runtime'")
+            .get();
+        const current = row?.owner_generation ?? 0;
+        if (current > generation) {
+            throw new StaleOwnerError(generation, current);
+        }
+    }
+}
+/**
+ * Assert the calling runtime is still the current owner of this database.
+ * Must be called inside the same SQLite transaction as the write.
+ * Throws StaleOwnerError if superseded.
+ */
+function assertDbOwnership(db, generation) {
+    const row = db
+        .prepare("SELECT owner_generation FROM owner_epoch WHERE scope = 'runtime'")
+        .get();
+    const current = row?.owner_generation ?? 0;
+    if (current > generation) {
+        throw new StaleOwnerError(generation, current);
+    }
+}

package/dist-cjs/network-runtime/delivery-receipts.d.ts

@@ -0,0 +1,117 @@
+import { z } from "zod";
+export declare const RuntimeTransportSchema: z.ZodEnum<{
+    in_process: "in_process";
+    local_runtime: "local_runtime";
+    tunnel: "tunnel";
+    relay: "relay";
+}>;
+export type RuntimeTransport = z.infer<typeof RuntimeTransportSchema>;
+export declare const DeliveryStateSchema: z.ZodEnum<{
+    expired: "expired";
+    rejected: "rejected";
+    accepted: "accepted";
+    queued_for_route: "queued_for_route";
+    dispatching: "dispatching";
+    sent: "sent";
+    acked: "acked";
+    failed: "failed";
+}>;
+export type DeliveryState = z.infer<typeof DeliveryStateSchema>;
+export declare const SessionStateSchema: z.ZodEnum<{
+    none: "none";
+    handshaking: "handshaking";
+    connected: "connected";
+    reconnecting: "reconnecting";
+    dead: "dead";
+}>;
+export type SessionState = z.infer<typeof SessionStateSchema>;
+export declare const DeliveryReadinessSchema: z.ZodEnum<{
+    cannot_address: "cannot_address";
+    can_queue_only: "can_queue_only";
+    can_send_now: "can_send_now";
+}>;
+export type DeliveryReadiness = z.infer<typeof DeliveryReadinessSchema>;
+export declare const QueuedReasonSchema: z.ZodEnum<{
+    route_not_established: "route_not_established";
+    awaiting_remote_ack: "awaiting_remote_ack";
+    transport_unavailable: "transport_unavailable";
+}>;
+export type QueuedReason = z.infer<typeof QueuedReasonSchema>;
+export declare const OutboxReceiptStatusSchema: z.ZodEnum<{
+    expired: "expired";
+    queued_for_route: "queued_for_route";
+    dispatching: "dispatching";
+    acked: "acked";
+}>;
+export type OutboxReceiptStatus = z.infer<typeof OutboxReceiptStatusSchema>;
+export declare const DeliveryReceiptInputSchema: z.ZodObject<{
+    transport: z.ZodEnum<{
+        in_process: "in_process";
+        local_runtime: "local_runtime";
+        tunnel: "tunnel";
+        relay: "relay";
+    }>;
+    delivered: z.ZodBoolean;
+    queued: z.ZodBoolean;
+    accepted: z.ZodOptional<z.ZodBoolean>;
+    deliveryState: z.ZodOptional<z.ZodEnum<{
+        expired: "expired";
+        rejected: "rejected";
+        accepted: "accepted";
+        queued_for_route: "queued_for_route";
+        dispatching: "dispatching";
+        sent: "sent";
+        acked: "acked";
+        failed: "failed";
+    }>>;
+    sessionState: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        handshaking: "handshaking";
+        connected: "connected";
+        reconnecting: "reconnecting";
+        dead: "dead";
+    }>>;
+    deliveryReadiness: z.ZodOptional<z.ZodEnum<{
+        cannot_address: "cannot_address";
+        can_queue_only: "can_queue_only";
+        can_send_now: "can_send_now";
+    }>>;
+    queuedReason: z.ZodOptional<z.ZodEnum<{
+        route_not_established: "route_not_established";
+        awaiting_remote_ack: "awaiting_remote_ack";
+        transport_unavailable: "transport_unavailable";
+    }>>;
+}, z.core.$strict>;
+export type DeliveryReceiptInput = z.input<typeof DeliveryReceiptInputSchema>;
+export interface CanonicalDeliveryReceipt {
+    transport: RuntimeTransport;
+    delivered: boolean;
+    queued: boolean;
+    accepted: boolean;
+    deliveryState: DeliveryState;
+    sessionState: SessionState;
+    deliveryReadiness: DeliveryReadiness;
+    queuedReason?: QueuedReason;
+}
+export declare function canonicalizeDeliveryReceipt(input: DeliveryReceiptInput): CanonicalDeliveryReceipt;
+export declare function createAckedDeliveryReceipt(input: {
+    transport: RuntimeTransport;
+    sessionState?: SessionState;
+    deliveryReadiness?: DeliveryReadiness;
+}): CanonicalDeliveryReceipt;
+export declare function createQueuedForRouteReceipt(input: {
+    transport: RuntimeTransport;
+    sessionState?: SessionState;
+    deliveryReadiness?: DeliveryReadiness;
+}): CanonicalDeliveryReceipt;
+export declare function createDispatchingDeliveryReceipt(input: {
+    transport: RuntimeTransport;
+    sessionState?: SessionState;
+    deliveryReadiness?: DeliveryReadiness;
+}): CanonicalDeliveryReceipt;
+export declare function createSentDeliveryReceipt(input: {
+    transport: RuntimeTransport;
+    sessionState?: SessionState;
+    deliveryReadiness?: DeliveryReadiness;
+}): CanonicalDeliveryReceipt;
+export declare function canonicalizeOutboxReceiptStatus(status: string): OutboxReceiptStatus;

package/dist-cjs/network-runtime/delivery-receipts.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeliveryReceiptInputSchema = exports.OutboxReceiptStatusSchema = exports.QueuedReasonSchema = exports.DeliveryReadinessSchema = exports.SessionStateSchema = exports.DeliveryStateSchema = exports.RuntimeTransportSchema = void 0;
+exports.canonicalizeDeliveryReceipt = canonicalizeDeliveryReceipt;
+exports.createAckedDeliveryReceipt = createAckedDeliveryReceipt;
+exports.createQueuedForRouteReceipt = createQueuedForRouteReceipt;
+exports.createDispatchingDeliveryReceipt = createDispatchingDeliveryReceipt;
+exports.createSentDeliveryReceipt = createSentDeliveryReceipt;
+exports.canonicalizeOutboxReceiptStatus = canonicalizeOutboxReceiptStatus;
+const zod_1 = require("zod");
+exports.RuntimeTransportSchema = zod_1.z.enum(["in_process", "local_runtime", "tunnel", "relay"]);
+exports.DeliveryStateSchema = zod_1.z.enum([
+    "accepted",
+    "queued_for_route",
+    "dispatching",
+    "sent",
+    "acked",
+    "expired",
+    "failed",
+    "rejected",
+]);
+exports.SessionStateSchema = zod_1.z.enum(["none", "handshaking", "connected", "reconnecting", "dead"]);
+exports.DeliveryReadinessSchema = zod_1.z.enum([
+    "cannot_address",
+    "can_queue_only",
+    "can_send_now",
+]);
+exports.QueuedReasonSchema = zod_1.z.enum([
+    "route_not_established",
+    "awaiting_remote_ack",
+    "transport_unavailable",
+]);
+exports.OutboxReceiptStatusSchema = zod_1.z.enum([
+    "queued_for_route",
+    "dispatching",
+    "acked",
+    "expired",
+]);
+exports.DeliveryReceiptInputSchema = zod_1.z
+    .object({
+    transport: exports.RuntimeTransportSchema,
+    delivered: zod_1.z.boolean(),
+    queued: zod_1.z.boolean(),
+    accepted: zod_1.z.boolean().optional(),
+    deliveryState: exports.DeliveryStateSchema.optional(),
+    sessionState: exports.SessionStateSchema.optional(),
+    deliveryReadiness: exports.DeliveryReadinessSchema.optional(),
+    queuedReason: exports.QueuedReasonSchema.optional(),
+})
+    .strict();
+const DELIVERY_STATE_RESTRICTIVENESS = {
+    rejected: 0,
+    failed: 1,
+    expired: 2,
+    queued_for_route: 3,
+    dispatching: 4,
+    accepted: 5,
+    sent: 6,
+    acked: 7,
+};
+const SESSION_STATE_RESTRICTIVENESS = {
+    dead: 0,
+    none: 1,
+    handshaking: 2,
+    reconnecting: 3,
+    connected: 4,
+};
+const DELIVERY_READINESS_RESTRICTIVENESS = {
+    cannot_address: 0,
+    can_queue_only: 1,
+    can_send_now: 2,
+};
+function inferLegacyDeliveryState(input, accepted) {
+    if (!accepted) {
+        return input.deliveryState === "rejected" ? "rejected" : "failed";
+    }
+    if (input.delivered) {
+        return "acked";
+    }
+    if (input.queued) {
+        if (input.queuedReason === "awaiting_remote_ack" ||
+            input.deliveryState === "dispatching" ||
+            input.deliveryState === "sent") {
+            return "dispatching";
+        }
+        return "queued_for_route";
+    }
+    if (input.deliveryState === "expired") {
+        return "expired";
+    }
+    return "sent";
+}
+function normalizeExplicitDeliveryState(input) {
+    if (!input.deliveryState) {
+        return undefined;
+    }
+    if (input.deliveryState === "sent" &&
+        input.queued &&
+        input.queuedReason === "awaiting_remote_ack") {
+        return "dispatching";
+    }
+    return input.deliveryState;
+}
+function chooseMoreRestrictiveDeliveryState(left, right) {
+    return DELIVERY_STATE_RESTRICTIVENESS[left] <= DELIVERY_STATE_RESTRICTIVENESS[right]
+        ? left
+        : right;
+}
+function inferSessionStateFromDeliveryState(transport, deliveryState) {
+    if (transport === "local_runtime") {
+        return "none";
+    }
+    switch (deliveryState) {
+        case "queued_for_route":
+            return "handshaking";
+        case "dispatching":
+            return "connected";
+        case "failed":
+        case "rejected":
+        case "expired":
+            return "none";
+        case "acked":
+            return "connected";
+        case "accepted":
+        case "sent":
+            return "connected";
+        default:
+            return "none";
+    }
+}
+function chooseMoreRestrictiveSessionState(transport, explicit, inferred) {
+    if (transport === "local_runtime") {
+        return "none";
+    }
+    if (!explicit) {
+        return inferred;
+    }
+    return SESSION_STATE_RESTRICTIVENESS[explicit] <= SESSION_STATE_RESTRICTIVENESS[inferred]
+        ? explicit
+        : inferred;
+}
+function inferDeliveryReadinessFromState(transport, deliveryState, sessionState) {
+    if (deliveryState === "failed" || deliveryState === "rejected") {
+        return "cannot_address";
+    }
+    if (transport === "local_runtime" && deliveryState === "acked") {
+        return "can_queue_only";
+    }
+    if (deliveryState === "queued_for_route") {
+        return "can_queue_only";
+    }
+    if (deliveryState === "dispatching") {
+        return sessionState === "reconnecting" ? "can_queue_only" : "can_send_now";
+    }
+    if (deliveryState === "expired") {
+        return "cannot_address";
+    }
+    return sessionState === "connected" ? "can_send_now" : "can_queue_only";
+}
+function chooseMoreRestrictiveDeliveryReadiness(explicit, inferred) {
+    if (!explicit) {
+        return inferred;
+    }
+    return DELIVERY_READINESS_RESTRICTIVENESS[explicit] <=
+        DELIVERY_READINESS_RESTRICTIVENESS[inferred]
+        ? explicit
+        : inferred;
+}
+function deriveCanonicalAccepted(input, deliveryState) {
+    if (deliveryState === "rejected") {
+        return false;
+    }
+    return input.accepted ?? true;
+}
+function isQueuedDeliveryState(deliveryState) {
+    return deliveryState === "queued_for_route" || deliveryState === "dispatching";
+}
+function inferQueuedReason(input, deliveryState, queued) {
+    if (!queued) {
+        return undefined;
+    }
+    if (input.queuedReason) {
+        return input.queuedReason;
+    }
+    if (deliveryState === "dispatching") {
+        return "awaiting_remote_ack";
+    }
+    if (deliveryState === "queued_for_route") {
+        return "route_not_established";
+    }
+    return undefined;
+}
+function canonicalizeDeliveryReceipt(input) {
+    const inferredDeliveryState = inferLegacyDeliveryState(input, input.accepted ?? true);
+    const explicitDeliveryState = normalizeExplicitDeliveryState(input);
+    const deliveryState = explicitDeliveryState
+        ? chooseMoreRestrictiveDeliveryState(explicitDeliveryState, inferredDeliveryState)
+        : inferredDeliveryState;
+    const accepted = deriveCanonicalAccepted(input, deliveryState);
+    const delivered = deliveryState === "acked";
+    const queued = isQueuedDeliveryState(deliveryState);
+    const inferredSessionState = inferSessionStateFromDeliveryState(input.transport, deliveryState);
+    const sessionState = chooseMoreRestrictiveSessionState(input.transport, input.sessionState, inferredSessionState);
+    const inferredDeliveryReadiness = inferDeliveryReadinessFromState(input.transport, deliveryState, sessionState);
+    const deliveryReadiness = chooseMoreRestrictiveDeliveryReadiness(input.deliveryReadiness, inferredDeliveryReadiness);
+    const queuedReason = inferQueuedReason(input, deliveryState, queued);
+    return {
+        transport: input.transport,
+        delivered,
+        queued,
+        accepted,
+        deliveryState,
+        sessionState,
+        deliveryReadiness,
+        ...(queuedReason ? { queuedReason } : {}),
+    };
+}
+function createAckedDeliveryReceipt(input) {
+    return canonicalizeDeliveryReceipt({
+        transport: input.transport,
+        delivered: true,
+        queued: false,
+        accepted: true,
+        deliveryState: "acked",
+        ...(input.sessionState ? { sessionState: input.sessionState } : {}),
+        ...(input.deliveryReadiness ? { deliveryReadiness: input.deliveryReadiness } : {}),
+    });
+}
+function createQueuedForRouteReceipt(input) {
+    return canonicalizeDeliveryReceipt({
+        transport: input.transport,
+        delivered: false,
+        queued: true,
+        accepted: true,
+        deliveryState: "queued_for_route",
+        queuedReason: "route_not_established",
+        ...(input.sessionState ? { sessionState: input.sessionState } : {}),
+        ...(input.deliveryReadiness ? { deliveryReadiness: input.deliveryReadiness } : {}),
+    });
+}
+function createDispatchingDeliveryReceipt(input) {
+    return canonicalizeDeliveryReceipt({
+        transport: input.transport,
+        delivered: false,
+        queued: true,
+        accepted: true,
+        deliveryState: "dispatching",
+        queuedReason: "awaiting_remote_ack",
+        ...(input.sessionState ? { sessionState: input.sessionState } : {}),
+        ...(input.deliveryReadiness ? { deliveryReadiness: input.deliveryReadiness } : {}),
+    });
+}
+function createSentDeliveryReceipt(input) {
+    return canonicalizeDeliveryReceipt({
+        transport: input.transport,
+        delivered: false,
+        queued: false,
+        accepted: true,
+        deliveryState: "sent",
+        ...(input.sessionState ? { sessionState: input.sessionState } : {}),
+        ...(input.deliveryReadiness ? { deliveryReadiness: input.deliveryReadiness } : {}),
+    });
+}
+function canonicalizeOutboxReceiptStatus(status) {
+    switch (status) {
+        case "queued":
+        case "queued_for_route":
+            return "queued_for_route";
+        case "dispatching":
+        case "acked":
+        case "expired":
+            return status;
+        default:
+            throw new Error(`[delivery-receipts] Unsupported outbox status: ${status}`);
+    }
+}

package/dist-cjs/network-runtime/direct-endpoint-authority.d.ts

@@ -0,0 +1,8 @@
+export declare function isLoopbackDirectEndpointHost(host: string): boolean;
+export declare function canonicalizeAuthoritativeDirectEndpoint(input: {
+    endpointHost?: string | null;
+    endpointPort?: number | null;
+}): {
+    endpointHost?: string;
+    endpointPort?: number;
+};