@aria-cli/tools 1.0.12 → 1.0.14

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

@@ -1,267 +0,0 @@
-import { z } from "zod";
-export const RuntimeTransportSchema = z.enum(["in_process", "local_runtime", "tunnel", "relay"]);
-export const DeliveryStateSchema = z.enum([
-    "accepted",
-    "queued_for_route",
-    "dispatching",
-    "sent",
-    "acked",
-    "expired",
-    "failed",
-    "rejected",
-]);
-export const SessionStateSchema = z.enum(["none", "handshaking", "connected", "reconnecting", "dead"]);
-export const DeliveryReadinessSchema = z.enum([
-    "cannot_address",
-    "can_queue_only",
-    "can_send_now",
-]);
-export const QueuedReasonSchema = z.enum([
-    "route_not_established",
-    "awaiting_remote_ack",
-    "transport_unavailable",
-]);
-export const OutboxReceiptStatusSchema = z.enum([
-    "queued_for_route",
-    "dispatching",
-    "acked",
-    "expired",
-]);
-export const DeliveryReceiptInputSchema = z
-    .object({
-    transport: RuntimeTransportSchema,
-    delivered: z.boolean(),
-    queued: z.boolean(),
-    accepted: z.boolean().optional(),
-    deliveryState: DeliveryStateSchema.optional(),
-    sessionState: SessionStateSchema.optional(),
-    deliveryReadiness: DeliveryReadinessSchema.optional(),
-    queuedReason: 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;
-}
-export 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 } : {}),
-    };
-}
-export 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 } : {}),
-    });
-}
-export 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 } : {}),
-    });
-}
-export 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 } : {}),
-    });
-}
-export 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 } : {}),
-    });
-}
-export 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/network-runtime/direct-endpoint-authority.js

@@ -1,25 +0,0 @@
-function normalizeHost(host) {
-    return host.trim().toLowerCase();
-}
-export function isLoopbackDirectEndpointHost(host) {
-    const normalized = normalizeHost(host);
-    return (normalized === "localhost" ||
-        normalized === "::1" ||
-        normalized === "[::1]" ||
-        normalized.endsWith(".localhost") ||
-        /^127\./.test(normalized));
-}
-export function canonicalizeAuthoritativeDirectEndpoint(input) {
-    const rawHost = input.endpointHost?.trim();
-    const port = input.endpointPort;
-    if (!rawHost || typeof port !== "number" || !Number.isFinite(port)) {
-        return {};
-    }
-    if (isLoopbackDirectEndpointHost(rawHost)) {
-        return {};
-    }
-    return {
-        endpointHost: rawHost,
-        endpointPort: port,
-    };
-}