@masons/agent-network 0.6.15 → 0.6.16

package/dist/_vendor/runtime-adapter-client/runtime-adapter-api.js

@@ -0,0 +1,3112 @@
+import { findPeerVisibleRuntimeMetadataKeys } from "./conformance.js";
+import { isRuntimeDebugIdentifierTitle, parseRuntimeSessionDisplayMetadata, parseRuntimeSessionIdentityKey, } from "./icm.js";
+import { ADAPTER_RUNTIME_PROCESSING_STATES, RUNTIME_ASSIGNMENT_FAILURE_CATEGORIES, } from "./types.js";
+import { parseRuntimeWorkTargetRef, sameRuntimeWorkTargetRef, } from "./work-target.js";
+export const TARGET_MESSAGING_MEDIA_TYPE = "application/vnd.masons.icm-messaging-v1+json";
+export class RuntimeAdapterApiError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.name = "RuntimeAdapterApiError";
+        this.status = status;
+        this.code = code;
+    }
+}
+export class RuntimeAdapterNetworkError extends Error {
+    code;
+    detail;
+    requestKind;
+    constructor(code, detail, requestKind) {
+        super(`runtime adapter ${code}: ${detail}`);
+        this.name = "RuntimeAdapterNetworkError";
+        this.code = code;
+        this.detail = detail;
+        this.requestKind = requestKind;
+    }
+}
+const DEFAULT_REQUEST_TIMEOUT_MS = {
+    register_runtime_endpoint: 15_000,
+    heartbeat_runtime_endpoint: 10_000,
+    transition_runtime_endpoint_state: 15_000,
+    update_runtime_endpoint_display_metadata: 15_000,
+    unregister_runtime_endpoint: 15_000,
+    list_owned_runtime_endpoints: 20_000,
+    get_owned_runtime_endpoint: 20_000,
+    list_runtime_claim_candidates: 30_000,
+    read_runtime_session_conversation_history: 30_000,
+    dispatch_runtime_undispatched: 15_000,
+    init_runtime_owner_action_handoff: 15_000,
+    poll_runtime_owner_action_handoff: 15_000,
+    claim_runtime_self_assignment: 15_000,
+    release_runtime_self_assignment: 15_000,
+    settle_runtime_mailbox_item: 15_000,
+    dismiss_runtime_undispatched: 15_000,
+    create_runtime_assignment_reply_intent: 15_000,
+    create_runtime_outbound_message_intent: 15_000,
+    list_runtime_directed_session_targets: 15_000,
+    submit_runtime_target_send: 15_000,
+    read_runtime_target_attempt_outcome: 15_000,
+    read_runtime_target_message_outcome: 15_000,
+    acquire_node_recipient_message: 10_000,
+    submit_node_recipient_message_admission_evidence: 15_000,
+    acquire_services_retained_node_recipient_message: 10_000,
+    consume_services_retained_node_recipient_message: 15_000,
+    acquire_exact_target_presentation: 10_000,
+    submit_exact_target_recipient_admission_evidence: 15_000,
+    submit_exact_target_presentation_evidence: 15_000,
+    release_exact_target_presentation: 15_000,
+    emit_runtime_processing_state: 15_000,
+};
+export async function registerRuntimeEndpoint(cfg, runtimeKey, params) {
+    const res = await apiFetch(cfg, "register_runtime_endpoint", `${baseUrl(cfg)}/runtime-endpoints`, {
+        method: "POST",
+        headers: jsonHeaders(runtimeKey),
+        body: JSON.stringify(params),
+    });
+    if (!res.ok)
+        return handleError(res);
+    return readRegisterRuntimeEndpointResponse(await res.json().catch(() => null));
+}
+export async function heartbeatRuntimeEndpoint(cfg, runtimeKey, endpointId) {
+    const res = await apiFetch(cfg, "heartbeat_runtime_endpoint", `${baseUrl(cfg)}/runtime-endpoints/${encodeURIComponent(endpointId)}/heartbeat`, {
+        method: "POST",
+        headers: authHeaders(runtimeKey),
+    });
+    if (!res.ok)
+        return handleError(res);
+    return ((await res.json().catch(() => ({}))) ?? {});
+}
+export async function transitionRuntimeEndpointState(cfg, runtimeKey, endpointId, params) {
+    const res = await apiFetch(cfg, "transition_runtime_endpoint_state", `${baseUrl(cfg)}/runtime-endpoints/${encodeURIComponent(endpointId)}/state`, {
+        method: "POST",
+        headers: jsonHeaders(runtimeKey),
+        body: JSON.stringify(params),
+    });
+    if (!res.ok)
+        return handleError(res);
+    return ((await res.json().catch(() => ({}))) ??
+        {});
+}
+export async function updateRuntimeEndpointDisplayMetadata(cfg, runtimeKey, endpointId, params) {
+    const res = await apiFetch(cfg, "update_runtime_endpoint_display_metadata", `${baseUrl(cfg)}/runtime-endpoints/${encodeURIComponent(endpointId)}/display-metadata`, {
+        method: "POST",
+        headers: jsonHeaders(runtimeKey),
+        body: JSON.stringify(params),
+    });
+    if (!res.ok)
+        return handleError(res);
+}
+export async function unregisterRuntimeEndpoint(cfg, runtimeKey, endpointId, asNodeId) {
+    const query = asNodeId
+        ? `?${new URLSearchParams({ as: asNodeId }).toString()}`
+        : "";
+    const res = await apiFetch(cfg, "unregister_runtime_endpoint", `${baseUrl(cfg)}/runtime-endpoints/${encodeURIComponent(endpointId)}${query}`, {
+        method: "DELETE",
+        headers: authHeaders(runtimeKey),
+    });
+    if (!res.ok)
+        return handleError(res);
+    return ((await res.json().catch(() => ({}))) ??
+        {});
+}
+export async function listOwnedRuntimeEndpoints(cfg, runtimeKey, asNodeId, options = {}) {
+    const query = new URLSearchParams({ as: asNodeId }).toString();
+    const res = await apiFetch(cfg, "list_owned_runtime_endpoints", `${baseUrl(cfg)}/runtime-endpoints?${query}`, {
+        headers: endpointReadHeaders(runtimeKey, options),
+    });
+    if (!res.ok)
+        return handleError(res);
+    return readListOwnedRuntimeEndpointsResponse(await res.json().catch(() => null));
+}
+export async function getOwnedRuntimeEndpoint(cfg, runtimeKey, endpointId, asNodeId, options = {}) {
+    const query = new URLSearchParams({ as: asNodeId }).toString();
+    const res = await apiFetch(cfg, "get_owned_runtime_endpoint", `${baseUrl(cfg)}/runtime-endpoints/${encodeURIComponent(endpointId)}?${query}`, {
+        headers: endpointReadHeaders(runtimeKey, options),
+    });
+    if (!res.ok)
+        return handleError(res);
+    return readOwnedRuntimeEndpointView(await res.json().catch(() => null));
+}
+export async function listRuntimeClaimCandidates(cfg, runtimeKey, params) {
+    const res = await apiFetch(cfg, "list_runtime_claim_candidates", `${baseUrl(cfg)}/runtime/claim-candidates`, {
+        method: "POST",
+        headers: jsonHeaders(runtimeKey),
+        body: JSON.stringify({
+            type: "runtime_claim_candidates",
+            version: 1,
+            endpoint_id: params.endpoint_id,
+            endpoint_nonce: params.endpoint_nonce,
+            ...(params.limit !== undefined && { limit: params.limit }),
+        }),
+    });
+    if (!res.ok) {
+        const error = await readErrorEnvelope(res);
+        throw new RuntimeAdapterApiError(res.status, error.code ?? "claim_candidates_failed", error.message ?? res.statusText);
+    }
+    const raw = (await res.json().catch(() => null));
+    const rawItems = typeof raw === "object" &&
+        raw !== null &&
+        !Array.isArray(raw) &&
+        Array.isArray(raw.items)
+        ? raw.items
+        : null;
+    if (!rawItems) {
+        throw new RuntimeAdapterApiError(502, "invalid_claim_candidates_response", "invalid claim-candidates response");
+    }
+    const items = [];
+    for (const rawItem of rawItems) {
+        const item = parseRuntimeClaimCandidate(rawItem);
+        if (!item) {
+            throw new RuntimeAdapterApiError(502, "invalid_claim_candidates_item", "invalid claim-candidates item");
+        }
+        items.push(item);
+    }
+    return { items };
+}
+export async function readRuntimeSessionConversationHistory(cfg, runtimeKey, params) {
+    const res = await apiFetch(cfg, "read_runtime_session_conversation_history", `${baseUrl(cfg)}/runtime/session-conversation-history`, {
+        method: "POST",
+        headers: jsonHeaders(runtimeKey),
+        body: JSON.stringify({
+            type: "runtime_session_conversation_history",
+            version: 1,
+            endpoint_id: params.endpoint_id,
+            endpoint_nonce: params.endpoint_nonce,
+            conversation_ref: params.conversation_ref,
+            ...(params.limit !== undefined && { limit: params.limit }),
+            ...(params.before !== undefined && { before: params.before }),
+            ...(params.after !== undefined && { after: params.after }),
+        }),
+    });
+    if (!res.ok) {
+        const error = await readErrorEnvelope(res);
+        throw new RuntimeAdapterApiError(res.status, error.code ?? "runtime_conversation_history_failed", error.message ?? res.statusText);
+    }
+    const raw = (await res.json().catch(() => null));
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        throw new RuntimeAdapterApiError(502, "invalid_runtime_conversation_history_response", "invalid runtime conversation history response");
+    }
+    const body = raw;
+    const conversationRef = parseRuntimeConversationRef(body.conversation_ref);
+    const rawItems = Array.isArray(body.items) ? body.items : null;
+    if (!conversationRef || !rawItems || typeof body.has_more !== "boolean") {
+        throw new RuntimeAdapterApiError(502, "invalid_runtime_conversation_history_response", "invalid runtime conversation history response");
+    }
+    if (conversationRef.kind !== params.conversation_ref.kind ||
+        conversationRef.id !== params.conversation_ref.id) {
+        throw new RuntimeAdapterApiError(502, "runtime_conversation_history_ref_mismatch", "runtime conversation history response did not match the requested conversation_ref");
+    }
+    const items = [];
+    for (const rawItem of rawItems) {
+        const item = parseRuntimeConversationHistoryMessage(rawItem);
+        if (!item) {
+            throw new RuntimeAdapterApiError(502, "invalid_runtime_conversation_history_item", "invalid runtime conversation history item");
+        }
+        items.push(item);
+    }
+    return {
+        conversation_ref: conversationRef,
+        items,
+        has_more: body.has_more,
+    };
+}
+export async function dispatchRuntimeUndispatched(cfg, ownerAccessToken, params) {
+    const res = await apiFetch(cfg, "dispatch_runtime_undispatched", `${baseUrl(cfg)}/runtime/dispatch`, {
+        method: "POST",
+        headers: jsonHeaders(ownerAccessToken),
+        body: JSON.stringify({
+            undispatched_id: params.undispatched_id,
+            target_endpoint_id: params.target_endpoint_id,
+            ...(params.target_ref !== undefined && {
+                target_ref: params.target_ref,
+            }),
+            ...(params.idempotency_key !== undefined && {
+                idempotency_key: params.idempotency_key,
+            }),
+        }),
+    });
+    if (!res.ok)
+        return handleError(res);
+    return readRuntimeDispatchUndispatchedResponse(await res.json().catch(() => null));
+}
+export async function initRuntimeOwnerActionHandoff(cfg, runtimeKey, params) {
+    const res = await apiFetch(cfg, "init_runtime_owner_action_handoff", `${baseUrl(cfg)}/runtime/owner-action-handoffs/init`, {
+        method: "POST",
+        headers: jsonHeaders(runtimeKey),
+        body: JSON.stringify({
+            type: "runtime_owner_action_handoff_init",
+            version: 1,
+            action: "dispatch_undispatched",
+            undispatched_id: params.undispatched_id,
+            target_endpoint_id: params.target_endpoint_id,
+            endpoint_nonce: params.endpoint_nonce,
+            target_ref: params.target_ref,
+            ...(params.selection_hint !== undefined && {
+                selection_hint: params.selection_hint,
+            }),
+        }),
+    });
+    if (!res.ok)
+        return handleError(res);
+    return readRuntimeOwnerActionHandoffInitResponse(await res.json().catch(() => null));
+}
+export async function pollRuntimeOwnerActionHandoff(cfg, runtimeKey, params) {
+    const res = await apiFetch(cfg, "poll_runtime_owner_action_handoff", `${baseUrl(cfg)}/runtime/owner-action-handoffs/${encodeURIComponent(params.handoff_session_id)}/poll`, {
+        method: "POST",
+        headers: jsonHeaders(runtimeKey),
+        body: JSON.stringify({
+            type: "runtime_owner_action_handoff_poll",
+            version: 1,
+            target_endpoint_id: params.target_endpoint_id,
+            endpoint_nonce: params.endpoint_nonce,
+        }),
+    });
+    if (!res.ok)
+        return handleError(res);
+    return readRuntimeOwnerActionHandoffPollResponse(await res.json().catch(() => null));
+}
+export async function claimRuntimeSelfAssignment(cfg, runtimeKey, params) {
+    let res;
+    try {
+        res = await apiFetch(cfg, "claim_runtime_self_assignment", `${baseUrl(cfg)}/runtime/self-claim`, {
+            method: "POST",
+            headers: jsonHeaders(runtimeKey),
+            body: JSON.stringify({
+                undispatched_id: params.undispatched_id,
+                target_endpoint_id: params.target_endpoint_id,
+                endpoint_nonce: params.endpoint_nonce,
+                ...(params.expected_target_ref !== undefined && {
+                    expected_target_ref: params.expected_target_ref,
+                }),
+                ...(params.recover_existing !== undefined && {
+                    recover_existing: params.recover_existing,
+                }),
+            }),
+        });
+    }
+    catch (err) {
+        return {
+            ok: false,
+            terminal: false,
+            detail: networkDetail(err),
+        };
+    }
+    if (res.status === 200 || res.status === 201) {
+        const outcome = await readRuntimeSelfClaimSuccess(res, params);
+        if (!outcome.ok) {
+            const releaseParams = buildPostCasReleaseParams(outcome.postCasInvalidClaim, params.endpoint_nonce);
+            if (releaseParams) {
+                const releaseOutcome = await releaseRuntimeSelfAssignment(cfg, runtimeKey, releaseParams);
+                if (!releaseOutcome.ok) {
+                    return {
+                        ...outcome,
+                        detail: `${outcome.detail ?? "invalid self-claim response"}; release_failed: ${releaseOutcome.detail ?? releaseOutcome.status ?? "unknown"}`,
+                    };
+                }
+            }
+        }
+        return outcome;
+    }
+    if ([401, 403, 404, 409, 422].includes(res.status)) {
+        return {
+            ok: false,
+            terminal: true,
+            status: res.status,
+            detail: await readErrorDetail(res),
+        };
+    }
+    return {
+        ok: false,
+        terminal: false,
+        status: res.status,
+        detail: await readErrorDetail(res),
+    };
+}
+export async function releaseRuntimeSelfAssignment(cfg, runtimeKey, params) {
+    let res;
+    try {
+        res = await apiFetch(cfg, "release_runtime_self_assignment", `${baseUrl(cfg)}/runtime/self-claim/release`, {
+            method: "POST",
+            headers: jsonHeaders(runtimeKey),
+            body: JSON.stringify(params),
+        });
+    }
+    catch (err) {
+        return transientNetworkOutcome(err);
+    }
+    if (res.status === 204)
+        return { ok: true };
+    if ([401, 403, 404, 409, 422].includes(res.status)) {
+        return terminalHttpOutcome(res);
+    }
+    return transientHttpOutcome(res);
+}
+export async function settleRuntimeMailboxItem(cfg, runtimeKey, params) {
+    let res;
+    try {
+        res = await apiFetch(cfg, "settle_runtime_mailbox_item", `${baseUrl(cfg)}/runtime/self-settle`, {
+            method: "POST",
+            headers: jsonHeaders(runtimeKey),
+            body: JSON.stringify(params),
+        });
+    }
+    catch (err) {
+        return selfSettleFailureOutcome(transientNetworkOutcome(err));
+    }
+    if (res.ok) {
+        const body = await res.json().catch(() => null);
+        const parsed = readRuntimeSelfSettleResponse(body, params);
+        if (!parsed.ok) {
+            return {
+                ok: false,
+                terminal: true,
+                detail: parsed.detail,
+            };
+        }
+        return { ok: true, settle: parsed.settle };
+    }
+    if ([401, 403, 404, 409, 422].includes(res.status)) {
+        return selfSettleFailureOutcome(await terminalHttpOutcome(res));
+    }
+    return selfSettleFailureOutcome(await transientHttpOutcome(res));
+}
+export async function dismissRuntimeUndispatched(cfg, ownerAccessToken, params) {
+    const res = await apiFetch(cfg, "dismiss_runtime_undispatched", `${baseUrl(cfg)}/runtime/undispatched-dismiss`, {
+        method: "POST",
+        headers: jsonHeaders(ownerAccessToken),
+        body: JSON.stringify(params),
+    });
+    if (!res.ok)
+        return handleError(res);
+    return readRuntimeUndispatchedDismissResponse(await res.json().catch(() => null), params);
+}
+function selfSettleFailureOutcome(outcome) {
+    if (!outcome.ok)
+        return outcome;
+    return {
+        ok: false,
+        terminal: false,
+        detail: "runtime self-settle completed without a response body",
+    };
+}
+export async function createRuntimeAssignmentReplyIntent(cfg, runtimeKey, params) {
+    const res = await apiFetch(cfg, "create_runtime_assignment_reply_intent", `${baseUrl(cfg)}/runtime/assignment-reply`, {
+        method: "POST",
+        headers: jsonHeaders(runtimeKey),
+        body: JSON.stringify({
+            type: "runtime_assignment_reply_request",
+            version: 1,
+            endpoint_id: params.endpoint_id,
+            endpoint_nonce: params.endpoint_nonce,
+            source_message_id: params.source_message_id,
+            assignment_id: params.assignment_id,
+            reply_request_id: params.reply_request_id,
+            content: params.content,
+            ...(params.content_type !== undefined && {
+                content_type: params.content_type,
+            }),
+            ...(params.metadata !== undefined && { metadata: params.metadata }),
+        }),
+    });
+    if (!res.ok)
+        return handleError(res);
+    return readRuntimeAssignmentReplyIntentResponse(await res.json().catch(() => null));
+}
+export async function createRuntimeOutboundMessageIntent(cfg, runtimeKey, params) {
+    const res = await apiFetch(cfg, "create_runtime_outbound_message_intent", `${baseUrl(cfg)}/runtime/outbound-message`, {
+        method: "POST",
+        headers: jsonHeaders(runtimeKey),
+        body: JSON.stringify({
+            type: "runtime_outbound_message_request",
+            version: 1,
+            endpoint_id: params.endpoint_id,
+            endpoint_nonce: params.endpoint_nonce,
+            send_request_id: params.send_request_id,
+            to: params.to,
+            content: params.content,
+            ...(params.content_type !== undefined && {
+                content_type: params.content_type,
+            }),
+            ...(params.metadata !== undefined && { metadata: params.metadata }),
+        }),
+    });
+    if (!res.ok)
+        return handleError(res);
+    return readRuntimeOutboundMessageIntentResponse(await res.json().catch(() => null));
+}
+export async function listRuntimeDirectedSessionTargets(cfg, runtimeKey, params) {
+    const res = await apiFetch(cfg, "list_runtime_directed_session_targets", `${baseUrl(cfg)}/runtime/member-send`, {
+        method: "POST",
+        headers: jsonHeaders(runtimeKey),
+        body: JSON.stringify({
+            type: "list_runtime_session_targets",
+            version: 1,
+            ...params,
+        }),
+    });
+    if (!res.ok)
+        return handleError(res);
+    const parsed = readRuntimeDirectedSessionTargetPage(await res.json().catch(() => null));
+    if (!parsed) {
+        throw new RuntimeAdapterApiError(502, "invalid_directed_session_page", "invalid bounded directed Session page response");
+    }
+    return parsed;
+}
+export async function listRuntimeDirectedSessionActionTargets(cfg, runtimeKey, params) {
+    const res = await apiFetch(cfg, "list_runtime_directed_session_targets", `${baseUrl(cfg)}/runtime/member-send`, {
+        method: "POST",
+        headers: jsonHeaders(runtimeKey),
+        body: JSON.stringify({
+            type: "list_runtime_session_targets",
+            version: 2,
+            ...params,
+        }),
+    });
+    if (!res.ok)
+        return handleError(res);
+    const parsed = readRuntimeDirectedSessionActionTargetPage(await res.json().catch(() => null));
+    if (!parsed) {
+        throw new RuntimeAdapterApiError(502, "invalid_directed_session_action_projection", "invalid directed Session action target projection response");
+    }
+    return parsed;
+}
+export async function resolveRuntimeDirectedSessionTargets(cfg, runtimeKey, params) {
+    const res = await apiFetch(cfg, "list_runtime_directed_session_targets", `${baseUrl(cfg)}/runtime/member-send`, {
+        method: "POST",
+        headers: jsonHeaders(runtimeKey),
+        body: JSON.stringify({
+            type: "list_runtime_session_targets",
+            version: 3,
+            ...params,
+        }),
+    });
+    if (!res.ok)
+        return handleError(res);
+    const parsed = readRuntimeDirectedSessionResolutionResponse(await res.json().catch(() => null), params.query);
+    if (!parsed) {
+        throw new RuntimeAdapterApiError(502, "invalid_directed_session_resolution", "invalid directed Session target resolution response");
+    }
+    return parsed;
+}
+export async function submitRuntimeTargetSend(cfg, runtimeKey, params) {
+    const res = await apiFetch(cfg, "submit_runtime_target_send", `${baseUrl(cfg)}/messages`, {
+        method: "POST",
+        headers: targetMessagingHeaders(runtimeKey),
+        body: JSON.stringify(params),
+    });
+    if (!res.ok)
+        return handleError(res);
+    return readRuntimeTargetSendOutcomeOrThrow(await res.json().catch(() => null));
+}
+export async function readRuntimeTargetAttemptOutcome(cfg, runtimeKey, attemptRef) {
+    const res = await apiFetch(cfg, "read_runtime_target_attempt_outcome", `${baseUrl(cfg)}/sending-attempts/${encodeURIComponent(attemptRef)}/outcome`, {
+        method: "GET",
+        headers: targetMessagingReadHeaders(runtimeKey),
+    });
+    if (!res.ok)
+        return handleError(res);
+    const outcome = readRuntimeTargetSendOutcomeOrThrow(await res.json().catch(() => null));
+    if ("attempt_ref" in outcome && outcome.attempt_ref !== attemptRef) {
+        throw new RuntimeAdapterApiError(502, "invalid_target_attempt_outcome", "invalid TARGET attempt outcome response");
+    }
+    return outcome;
+}
+export async function readRuntimeTargetMessageOutcome(cfg, runtimeKey, messageRef) {
+    const res = await apiFetch(cfg, "read_runtime_target_message_outcome", `${baseUrl(cfg)}/messages/${encodeURIComponent(messageRef)}/outcome`, {
+        method: "GET",
+        headers: targetMessagingReadHeaders(runtimeKey),
+    });
+    if (!res.ok)
+        return handleError(res);
+    const outcome = parseRuntimeTargetMessageOutcome(await res.json().catch(() => null));
+    if (!outcome || outcome.message_ref !== messageRef) {
+        throw new RuntimeAdapterApiError(502, "invalid_target_message_outcome", "invalid TARGET Message outcome response");
+    }
+    return outcome;
+}
+function readRuntimeTargetSendOutcomeOrThrow(raw) {
+    const parsed = parseRuntimeTargetAttemptOutcome(raw) ??
+        parseRuntimeTargetMessageOutcome(raw);
+    if (!parsed) {
+        throw new RuntimeAdapterApiError(502, "invalid_target_send_outcome", "invalid TARGET send outcome response");
+    }
+    return parsed;
+}
+function parseRuntimeTargetAttemptOutcome(raw) {
+    if (!isRecord(raw) ||
+        !isNonEmptyString(raw.attempt_ref) ||
+        !isNonEmptyString(raw.projection_etag) ||
+        !isCanonicalIsoInstantValue(raw.outcome_at)) {
+        return null;
+    }
+    const common = {
+        attempt_ref: raw.attempt_ref,
+        projection_etag: raw.projection_etag,
+        outcome_at: raw.outcome_at,
+    };
+    if (raw.outcome === "refused") {
+        if (raw.refusal_code === "remote_definitive_refusal") {
+            if (!hasExactKeys(raw, [
+                "attempt_ref",
+                "local_outcome_recorded_at",
+                "outcome",
+                "outcome_at",
+                "projection_etag",
+                "refusal_code",
+                "remote_refusal_decided_at",
+            ]) ||
+                !isCanonicalIsoInstantValue(raw.remote_refusal_decided_at) ||
+                !isCanonicalIsoInstantValue(raw.local_outcome_recorded_at) ||
+                raw.outcome_at !== raw.local_outcome_recorded_at) {
+                return null;
+            }
+            return {
+                ...common,
+                outcome: "refused",
+                refusal_code: "remote_definitive_refusal",
+                remote_refusal_decided_at: raw.remote_refusal_decided_at,
+                local_outcome_recorded_at: raw.local_outcome_recorded_at,
+            };
+        }
+        if (!hasExactKeys(raw, [
+            "attempt_ref",
+            "outcome",
+            "outcome_at",
+            "projection_etag",
+            "refusal_code",
+        ]) ||
+            ![
+                "not_authorized",
+                "identity_not_admissible",
+                "invalid_target",
+                "invalid_declaration",
+                "capability_not_current",
+            ].includes(raw.refusal_code)) {
+            return null;
+        }
+        return {
+            ...common,
+            outcome: "refused",
+            refusal_code: raw.refusal_code,
+        };
+    }
+    if (raw.outcome === "placement_pending" ||
+        raw.outcome === "placement_lapsed") {
+        if (!hasExactKeys(raw, [
+            "attempt_ref",
+            "outcome",
+            "outcome_at",
+            "placement_deadline",
+            "projection_etag",
+        ]) ||
+            !isCanonicalIsoInstantValue(raw.placement_deadline) ||
+            (raw.outcome === "placement_lapsed" &&
+                Date.parse(raw.outcome_at) < Date.parse(raw.placement_deadline))) {
+            return null;
+        }
+        return {
+            ...common,
+            outcome: raw.outcome,
+            placement_deadline: raw.placement_deadline,
+        };
+    }
+    if (raw.outcome === "dispatch_pending" ||
+        raw.outcome === "acceptance_unconfirmed") {
+        if (!hasExactKeys(raw, [
+            "attempt_ref",
+            "outcome",
+            "outcome_at",
+            "projection_etag",
+        ])) {
+            return null;
+        }
+        return { ...common, outcome: raw.outcome };
+    }
+    return null;
+}
+function parseRuntimeTargetMessageOutcome(raw) {
+    if (!isRecord(raw) ||
+        !isNonEmptyString(raw.message_ref) ||
+        !isNonEmptyString(raw.conversation_ref) ||
+        !isNonEmptyString(raw.projection_etag) ||
+        raw.placement !== "placed" ||
+        !isCanonicalIsoInstantValue(raw.outcome_at)) {
+        return null;
+    }
+    const common = {
+        message_ref: raw.message_ref,
+        conversation_ref: raw.conversation_ref,
+        projection_etag: raw.projection_etag,
+        placement: "placed",
+        outcome_at: raw.outcome_at,
+    };
+    if (raw.custody === "held") {
+        if (!hasExactKeys(raw, [
+            "conversation_ref",
+            "custody",
+            "hold_deadline",
+            "message_ref",
+            "outcome_at",
+            "placement",
+            "projection_etag",
+        ]) ||
+            !isCanonicalIsoInstantValue(raw.hold_deadline)) {
+            return null;
+        }
+        return { ...common, custody: "held", hold_deadline: raw.hold_deadline };
+    }
+    if (raw.custody === "lapsed") {
+        if (!hasExactKeys(raw, [
+            "conversation_ref",
+            "custody",
+            "hold_deadline",
+            "lapsed_at",
+            "message_ref",
+            "outcome_at",
+            "placement",
+            "projection_etag",
+        ]) ||
+            !isCanonicalIsoInstantValue(raw.hold_deadline) ||
+            !isCanonicalIsoInstantValue(raw.lapsed_at) ||
+            raw.outcome_at !== raw.lapsed_at ||
+            Date.parse(raw.lapsed_at) < Date.parse(raw.hold_deadline)) {
+            return null;
+        }
+        return {
+            ...common,
+            custody: "lapsed",
+            hold_deadline: raw.hold_deadline,
+            lapsed_at: raw.lapsed_at,
+        };
+    }
+    if (raw.custody !== "taken")
+        return null;
+    if (hasExactKeys(raw, [
+        "conversation_ref",
+        "custody",
+        "custody_decided_at",
+        "hold_deadline",
+        "message_ref",
+        "outcome_at",
+        "placement",
+        "projection_etag",
+    ]) &&
+        isCanonicalIsoInstantValue(raw.hold_deadline) &&
+        isCanonicalIsoInstantValue(raw.custody_decided_at) &&
+        raw.outcome_at === raw.custody_decided_at) {
+        return {
+            ...common,
+            custody: "taken",
+            hold_deadline: raw.hold_deadline,
+            custody_decided_at: raw.custody_decided_at,
+        };
+    }
+    if (hasExactKeys(raw, [
+        "conversation_ref",
+        "custody",
+        "local_outcome_recorded_at",
+        "message_ref",
+        "outcome_at",
+        "placement",
+        "projection_etag",
+        "remote_custody_decided_at",
+    ]) &&
+        isCanonicalIsoInstantValue(raw.remote_custody_decided_at) &&
+        isCanonicalIsoInstantValue(raw.local_outcome_recorded_at) &&
+        raw.outcome_at === raw.local_outcome_recorded_at) {
+        return {
+            ...common,
+            custody: "taken",
+            remote_custody_decided_at: raw.remote_custody_decided_at,
+            local_outcome_recorded_at: raw.local_outcome_recorded_at,
+        };
+    }
+    return null;
+}
+function readRuntimeDirectedSessionTargetDirectory(raw) {
+    if (!isRecord(raw) || !Array.isArray(raw.nodes)) {
+        return null;
+    }
+    const nodes = [];
+    for (const rawNode of raw.nodes) {
+        const nodeLabelOrigin = isRecord(rawNode)
+            ? readRuntimeDirectedSessionLabelOrigin(rawNode.display)
+            : null;
+        if (!isRecord(rawNode) ||
+            !isNonEmptyString(rawNode.node_ref) ||
+            !isRecord(rawNode.display) ||
+            typeof rawNode.display.label !== "string" ||
+            nodeLabelOrigin === null ||
+            ![
+                "exact_sessions_complete",
+                "exact_sessions_not_applicable",
+                "exact_sessions_incomplete",
+            ].includes(rawNode.coverage) ||
+            !Array.isArray(rawNode.sessions)) {
+            return null;
+        }
+        const sessions = [];
+        for (const rawSession of rawNode.sessions) {
+            const sessionLabelOrigin = isRecord(rawSession)
+                ? readRuntimeDirectedSessionLabelOrigin(rawSession.display)
+                : null;
+            if (!isRecord(rawSession) ||
+                !isRecord(rawSession.display) ||
+                typeof rawSession.display.label !== "string" ||
+                sessionLabelOrigin === null ||
+                (rawSession.display.host_label !== undefined &&
+                    typeof rawSession.display.host_label !== "string") ||
+                typeof rawSession.target_ref !== "string") {
+                return null;
+            }
+            sessions.push({
+                display: {
+                    label: rawSession.display.label,
+                    label_origin: sessionLabelOrigin,
+                    ...(typeof rawSession.display.host_label === "string" && {
+                        host_label: rawSession.display.host_label,
+                    }),
+                },
+                target_ref: rawSession.target_ref,
+            });
+        }
+        nodes.push({
+            node_ref: rawNode.node_ref,
+            display: {
+                label: rawNode.display.label,
+                label_origin: nodeLabelOrigin,
+            },
+            coverage: rawNode.coverage,
+            sessions,
+        });
+    }
+    return { nodes };
+}
+function readRuntimeDirectedSessionTargetPage(raw) {
+    if (!isRecord(raw) ||
+        raw.status !== "exact_session_target_page" ||
+        raw.contract_version !== 1 ||
+        readRuntimeTargetSendSource(raw.acting_source) === null ||
+        !isRecord(raw.traversal) ||
+        raw.traversal.query_kind !== "all_owned_nodes" ||
+        typeof raw.traversal.traversal_ref !== "string" ||
+        !isPositiveInteger(raw.traversal.page) ||
+        raw.traversal.page_bound !== 12 ||
+        !isNonNegativeInteger(raw.traversal.entry_count) ||
+        raw.traversal.entry_count > 12 ||
+        !isNonNegativeInteger(raw.traversal.choice_count) ||
+        raw.traversal.choice_count > 12 ||
+        typeof raw.traversal.complete !== "boolean" ||
+        typeof raw.traversal.expires_at !== "string" ||
+        !isCanonicalIsoInstant(raw.traversal.expires_at) ||
+        (raw.traversal.continuation !== undefined &&
+            typeof raw.traversal.continuation !== "string") ||
+        raw.traversal.complete === (raw.traversal.continuation !== undefined) ||
+        !Array.isArray(raw.nodes) ||
+        raw.nodes.length > 12) {
+        return null;
+    }
+    for (const rawNode of raw.nodes) {
+        if (!isRecord(rawNode) ||
+            !isRecord(rawNode.display) ||
+            rawNode.display.label_origin === undefined ||
+            !Array.isArray(rawNode.sessions) ||
+            rawNode.sessions.some((rawSession) => !isRecord(rawSession) ||
+                !isRecord(rawSession.display) ||
+                rawSession.display.label_origin === undefined)) {
+            return null;
+        }
+    }
+    const directory = readRuntimeDirectedSessionTargetDirectory({
+        nodes: raw.nodes,
+    });
+    if (!directory)
+        return null;
+    const targetRefs = new Set();
+    const visibleTargets = new Set();
+    let choiceCount = 0;
+    let zeroSessionNodeCount = 0;
+    for (const node of directory.nodes) {
+        if (node.sessions.length === 0)
+            zeroSessionNodeCount += 1;
+        for (const session of node.sessions) {
+            choiceCount += 1;
+            if (targetRefs.has(session.target_ref))
+                return null;
+            targetRefs.add(session.target_ref);
+            const visibleTarget = JSON.stringify([
+                node.display.label,
+                session.display.label,
+                session.display.host_label ?? null,
+            ]);
+            if (visibleTargets.has(visibleTarget))
+                return null;
+            visibleTargets.add(visibleTarget);
+        }
+    }
+    if (choiceCount !== raw.traversal.choice_count ||
+        choiceCount + zeroSessionNodeCount !== raw.traversal.entry_count) {
+        return null;
+    }
+    return {
+        status: "exact_session_target_page",
+        contract_version: 1,
+        acting_source: readRuntimeTargetSendSource(raw.acting_source),
+        traversal: {
+            query_kind: "all_owned_nodes",
+            traversal_ref: raw.traversal.traversal_ref,
+            page: raw.traversal.page,
+            page_bound: 12,
+            entry_count: raw.traversal.entry_count,
+            choice_count: raw.traversal.choice_count,
+            complete: raw.traversal.complete,
+            expires_at: raw.traversal.expires_at,
+            ...(typeof raw.traversal.continuation === "string" && {
+                continuation: raw.traversal.continuation,
+            }),
+        },
+        nodes: directory.nodes,
+    };
+}
+function readRuntimeDirectedSessionActionTargetPage(raw) {
+    if (!isRecord(raw) ||
+        raw.status !== "exact_session_action_target_projection" ||
+        raw.contract_version !== 2 ||
+        readRuntimeTargetSendSource(raw.acting_source) === null ||
+        !isRecord(raw.current_online) ||
+        raw.current_online.status !== "unavailable" ||
+        raw.current_online.code !== "receiver_evidence_provider_unavailable" ||
+        !isRecord(raw.recent_conversations) ||
+        raw.recent_conversations.status !== "available" ||
+        typeof raw.recent_conversations.traversal_ref !== "string" ||
+        !isPositiveInteger(raw.recent_conversations.page) ||
+        raw.recent_conversations.page_bound !== 12 ||
+        !isNonNegativeInteger(raw.recent_conversations.entry_count) ||
+        raw.recent_conversations.entry_count > 12 ||
+        !isNonNegativeInteger(raw.recent_conversations.choice_count) ||
+        raw.recent_conversations.choice_count > 12 ||
+        typeof raw.recent_conversations.complete !== "boolean" ||
+        typeof raw.recent_conversations.expires_at !== "string" ||
+        !isCanonicalIsoInstant(raw.recent_conversations.expires_at) ||
+        (raw.recent_conversations.continuation !== undefined &&
+            typeof raw.recent_conversations.continuation !== "string") ||
+        raw.recent_conversations.complete ===
+            (raw.recent_conversations.continuation !== undefined) ||
+        !Array.isArray(raw.recent_conversations.rows) ||
+        raw.recent_conversations.rows.length > 12 ||
+        !isRecord(raw.directory_access) ||
+        raw.directory_access.status !== "available" ||
+        raw.directory_access.contract_version !== 1) {
+        return null;
+    }
+    const rows = [];
+    const targetRefs = new Set();
+    const visibleTargets = new Set();
+    let choiceCount = 0;
+    for (const rawRow of raw.recent_conversations.rows) {
+        const nodeOrigin = isRecord(rawRow)
+            ? readRuntimeDirectedSessionLabelOrigin(isRecord(rawRow.node) ? rawRow.node.display : null)
+            : null;
+        const sessionOrigin = isRecord(rawRow)
+            ? readRuntimeDirectedSessionLabelOrigin(isRecord(rawRow.session) ? rawRow.session.display : null)
+            : null;
+        if (!isRecord(rawRow) ||
+            !isRecord(rawRow.node) ||
+            !isNonEmptyString(rawRow.node.node_ref) ||
+            !isRecord(rawRow.node.display) ||
+            typeof rawRow.node.display.label !== "string" ||
+            nodeOrigin === null ||
+            !isRecord(rawRow.session) ||
+            !isRecord(rawRow.session.display) ||
+            typeof rawRow.session.display.label !== "string" ||
+            sessionOrigin === null ||
+            (rawRow.session.display.host_label !== undefined &&
+                typeof rawRow.session.display.host_label !== "string") ||
+            typeof rawRow.last_message_at !== "string" ||
+            !isCanonicalIsoInstant(rawRow.last_message_at) ||
+            !Array.isArray(rawRow.routes) ||
+            rawRow.routes.length > 1 ||
+            rawRow.routes.some((route) => route !== "exact_target_store") ||
+            (rawRow.target_ref !== undefined &&
+                !isNonEmptyString(rawRow.target_ref)) ||
+            (rawRow.routes.length === 1) !== isNonEmptyString(rawRow.target_ref)) {
+            return null;
+        }
+        if (isNonEmptyString(rawRow.target_ref)) {
+            choiceCount += 1;
+            if (targetRefs.has(rawRow.target_ref))
+                return null;
+            targetRefs.add(rawRow.target_ref);
+        }
+        const visibleTarget = JSON.stringify([
+            rawRow.node.display.label,
+            rawRow.session.display.label,
+            rawRow.session.display.host_label ?? null,
+        ]);
+        if (visibleTargets.has(visibleTarget))
+            return null;
+        visibleTargets.add(visibleTarget);
+        rows.push({
+            node: {
+                node_ref: rawRow.node.node_ref,
+                display: {
+                    label: rawRow.node.display.label,
+                    label_origin: nodeOrigin,
+                },
+            },
+            session: {
+                display: {
+                    label: rawRow.session.display.label,
+                    label_origin: sessionOrigin,
+                    ...(typeof rawRow.session.display.host_label === "string" && {
+                        host_label: rawRow.session.display.host_label,
+                    }),
+                },
+            },
+            last_message_at: rawRow.last_message_at,
+            routes: rawRow.routes.length === 1 ? ["exact_target_store"] : [],
+            ...(typeof rawRow.target_ref === "string" && {
+                target_ref: rawRow.target_ref,
+            }),
+        });
+    }
+    if (rows.length !== raw.recent_conversations.entry_count ||
+        choiceCount !== raw.recent_conversations.choice_count) {
+        return null;
+    }
+    return {
+        status: "exact_session_action_target_projection",
+        contract_version: 2,
+        acting_source: readRuntimeTargetSendSource(raw.acting_source),
+        current_online: {
+            status: "unavailable",
+            code: "receiver_evidence_provider_unavailable",
+        },
+        recent_conversations: {
+            status: "available",
+            traversal_ref: raw.recent_conversations.traversal_ref,
+            page: raw.recent_conversations.page,
+            page_bound: 12,
+            entry_count: raw.recent_conversations.entry_count,
+            choice_count: raw.recent_conversations.choice_count,
+            complete: raw.recent_conversations.complete,
+            expires_at: raw.recent_conversations.expires_at,
+            ...(typeof raw.recent_conversations.continuation === "string" && {
+                continuation: raw.recent_conversations.continuation,
+            }),
+            rows,
+        },
+        directory_access: { status: "available", contract_version: 1 },
+    };
+}
+function readRuntimeDirectedSessionResolutionNode(raw) {
+    if (!isRecord(raw) ||
+        !hasExactKeys(raw, ["node_ref", "display", "coverage"]) ||
+        !isNonEmptyString(raw.node_ref) ||
+        !isRecord(raw.display) ||
+        !hasExactKeys(raw.display, ["label", "label_origin"]) ||
+        !isNonEmptyString(raw.display.label) ||
+        ![
+            "exact_sessions_complete",
+            "exact_sessions_not_applicable",
+            "exact_sessions_incomplete",
+        ].includes(raw.coverage)) {
+        return null;
+    }
+    const labelOrigin = readRuntimeDirectedSessionLabelOrigin(raw.display);
+    if (labelOrigin === null)
+        return null;
+    return {
+        node_ref: raw.node_ref,
+        display: { label: raw.display.label, label_origin: labelOrigin },
+        coverage: raw.coverage,
+    };
+}
+function readRuntimeDirectedSessionResolutionSession(raw) {
+    if (!isRecord(raw) ||
+        !hasExactKeys(raw, ["display", "target_ref"]) ||
+        !isRecord(raw.display) ||
+        !hasExactKeys(raw.display, raw.display.host_label === undefined
+            ? ["label", "label_origin"]
+            : ["label", "label_origin", "host_label"]) ||
+        !isNonEmptyString(raw.display.label) ||
+        (raw.display.host_label !== undefined &&
+            !isNonEmptyString(raw.display.host_label)) ||
+        !isNonEmptyString(raw.target_ref)) {
+        return null;
+    }
+    const labelOrigin = readRuntimeDirectedSessionLabelOrigin(raw.display);
+    if (labelOrigin === null)
+        return null;
+    return {
+        display: {
+            label: raw.display.label,
+            label_origin: labelOrigin,
+            ...(typeof raw.display.host_label === "string" && {
+                host_label: raw.display.host_label,
+            }),
+        },
+        target_ref: raw.target_ref,
+    };
+}
+function readRuntimeDirectedSessionResolutionTraversal(raw) {
+    if (!isRecord(raw) ||
+        !hasExactKeys(raw, raw.continuation === undefined
+            ? [
+                "traversal_ref",
+                "page",
+                "page_bound",
+                "entry_count",
+                "choice_count",
+                "complete",
+                "expires_at",
+            ]
+            : [
+                "traversal_ref",
+                "page",
+                "page_bound",
+                "entry_count",
+                "choice_count",
+                "complete",
+                "expires_at",
+                "continuation",
+            ]) ||
+        !isNonEmptyString(raw.traversal_ref) ||
+        !isPositiveInteger(raw.page) ||
+        raw.page_bound !== 12 ||
+        !isNonNegativeInteger(raw.entry_count) ||
+        raw.entry_count > 12 ||
+        !isNonNegativeInteger(raw.choice_count) ||
+        raw.choice_count > 12 ||
+        typeof raw.complete !== "boolean" ||
+        !isCanonicalIsoInstantValue(raw.expires_at) ||
+        (raw.continuation !== undefined && !isNonEmptyString(raw.continuation)) ||
+        raw.complete === (raw.continuation !== undefined)) {
+        return null;
+    }
+    return {
+        traversal_ref: raw.traversal_ref,
+        page: raw.page,
+        page_bound: 12,
+        entry_count: raw.entry_count,
+        choice_count: raw.choice_count,
+        complete: raw.complete,
+        expires_at: raw.expires_at,
+        ...(typeof raw.continuation === "string" && {
+            continuation: raw.continuation,
+        }),
+    };
+}
+function readRuntimeDirectedSessionResolutionResponse(raw, expectedQuery) {
+    if (!isRecord(raw) ||
+        raw.contract_version !== 3 ||
+        readRuntimeTargetSendSource(raw.acting_source) === null) {
+        return null;
+    }
+    const actingSource = readRuntimeTargetSendSource(raw.acting_source);
+    if (raw.status === "runtime_node_target_resolution") {
+        if (expectedQuery.kind !== "node_match" ||
+            !hasExactKeys(raw, [
+                "status",
+                "contract_version",
+                "acting_source",
+                "query",
+                "outcome",
+                "nodes",
+            ]) ||
+            !isRecord(raw.query) ||
+            !hasExactKeys(raw.query, ["kind", "match", "handle"]) ||
+            raw.query.kind !== "node_match" ||
+            raw.query.match !== "canonical_handle_exact" ||
+            raw.query.handle !== expectedQuery.match.handle ||
+            (raw.outcome !== "zero" && raw.outcome !== "one") ||
+            !Array.isArray(raw.nodes) ||
+            raw.nodes.length !== (raw.outcome === "one" ? 1 : 0)) {
+            return null;
+        }
+        const nodes = raw.nodes.map(readRuntimeDirectedSessionResolutionNode);
+        if (nodes.some((node) => node === null))
+            return null;
+        return {
+            status: "runtime_node_target_resolution",
+            contract_version: 3,
+            acting_source: actingSource,
+            query: {
+                kind: "node_match",
+                match: "canonical_handle_exact",
+                handle: raw.query.handle,
+            },
+            outcome: raw.outcome,
+            nodes: nodes,
+        };
+    }
+    if (raw.status === "runtime_node_session_target_resolution") {
+        if (expectedQuery.kind !== "node_sessions" ||
+            expectedQuery.match === undefined ||
+            !hasExactKeys(raw, [
+                "status",
+                "contract_version",
+                "acting_source",
+                "query",
+                "node",
+                "outcome",
+                "sessions",
+            ]) ||
+            !isRecord(raw.query) ||
+            !hasExactKeys(raw.query, ["kind", "match", "node_ref", "label"]) ||
+            raw.query.kind !== "node_sessions" ||
+            raw.query.match !== "approved_display_exact" ||
+            !isNonEmptyString(raw.query.node_ref) ||
+            raw.query.node_ref !== expectedQuery.node_ref ||
+            raw.query.label !== expectedQuery.match.label ||
+            !["not_applicable", "zero", "one"].includes(raw.outcome) ||
+            !Array.isArray(raw.sessions) ||
+            raw.sessions.length > 12) {
+            return null;
+        }
+        const node = readRuntimeDirectedSessionResolutionNode(raw.node);
+        const sessions = raw.sessions.map(readRuntimeDirectedSessionResolutionSession);
+        const validCount = ((raw.outcome === "not_applicable" || raw.outcome === "zero") &&
+            sessions.length === 0) ||
+            (raw.outcome === "one" && sessions.length === 1);
+        if (!node ||
+            sessions.some((session) => session === null) ||
+            !validCount ||
+            raw.query.node_ref !== node.node_ref ||
+            (raw.outcome === "not_applicable") !==
+                (node.coverage === "exact_sessions_not_applicable") ||
+            (raw.outcome !== "not_applicable" &&
+                node.coverage !== "exact_sessions_complete")) {
+            return null;
+        }
+        const targetRefs = new Set(sessions.map((session) => session?.target_ref));
+        if (targetRefs.size !== sessions.length)
+            return null;
+        return {
+            status: "runtime_node_session_target_resolution",
+            contract_version: 3,
+            acting_source: actingSource,
+            query: {
+                kind: "node_sessions",
+                match: "approved_display_exact",
+                node_ref: raw.query.node_ref,
+                label: raw.query.label,
+            },
+            node,
+            outcome: raw.outcome,
+            sessions: sessions,
+        };
+    }
+    if (raw.status === "runtime_node_target_page") {
+        if (expectedQuery.kind !== "browse_nodes" ||
+            !hasExactKeys(raw, [
+                "status",
+                "contract_version",
+                "acting_source",
+                "query",
+                "traversal",
+                "nodes",
+            ]) ||
+            !isRecord(raw.query) ||
+            !hasExactKeys(raw.query, ["kind"]) ||
+            raw.query.kind !== "browse_nodes" ||
+            !Array.isArray(raw.nodes) ||
+            raw.nodes.length > 12) {
+            return null;
+        }
+        const traversal = readRuntimeDirectedSessionResolutionTraversal(raw.traversal);
+        const nodes = raw.nodes.map(readRuntimeDirectedSessionResolutionNode);
+        if (!traversal ||
+            nodes.some((node) => node === null) ||
+            traversal.entry_count !== nodes.length ||
+            traversal.choice_count !== nodes.length ||
+            new Set(nodes.map((node) => node?.node_ref)).size !== nodes.length) {
+            return null;
+        }
+        return {
+            status: "runtime_node_target_page",
+            contract_version: 3,
+            acting_source: actingSource,
+            query: { kind: "browse_nodes" },
+            traversal,
+            nodes: nodes,
+        };
+    }
+    if (raw.status === "runtime_node_session_target_page") {
+        if (expectedQuery.kind !== "node_sessions" ||
+            expectedQuery.match !== undefined ||
+            !hasExactKeys(raw, [
+                "status",
+                "contract_version",
+                "acting_source",
+                "query",
+                "node",
+                "traversal",
+                "sessions",
+            ]) ||
+            !isRecord(raw.query) ||
+            !hasExactKeys(raw.query, ["kind", "node_ref"]) ||
+            raw.query.kind !== "node_sessions" ||
+            !isNonEmptyString(raw.query.node_ref) ||
+            raw.query.node_ref !== expectedQuery.node_ref ||
+            !Array.isArray(raw.sessions) ||
+            raw.sessions.length > 12) {
+            return null;
+        }
+        const node = readRuntimeDirectedSessionResolutionNode(raw.node);
+        const traversal = readRuntimeDirectedSessionResolutionTraversal(raw.traversal);
+        const sessions = raw.sessions.map(readRuntimeDirectedSessionResolutionSession);
+        if (!node ||
+            !traversal ||
+            sessions.some((session) => session === null) ||
+            traversal.entry_count !== sessions.length ||
+            traversal.choice_count !== sessions.length ||
+            new Set(sessions.map((session) => session?.target_ref)).size !==
+                sessions.length ||
+            raw.query.node_ref !== node.node_ref ||
+            node.coverage === "exact_sessions_incomplete" ||
+            (node.coverage === "exact_sessions_not_applicable" &&
+                (sessions.length !== 0 || !traversal.complete))) {
+            return null;
+        }
+        return {
+            status: "runtime_node_session_target_page",
+            contract_version: 3,
+            acting_source: actingSource,
+            query: { kind: "node_sessions", node_ref: raw.query.node_ref },
+            node,
+            traversal,
+            sessions: sessions,
+        };
+    }
+    return null;
+}
+function readRuntimeDirectedSessionLabelOrigin(display) {
+    if (!isRecord(display))
+        return null;
+    const labelOrigin = display.label_origin;
+    if (typeof labelOrigin !== "string")
+        return null;
+    switch (labelOrigin) {
+        case "approved_display":
+        case "approved_display_with_query_discriminator":
+        case "query_discriminator_only":
+            return labelOrigin;
+        default:
+            return null;
+    }
+}
+function readRuntimeTargetSendSource(value) {
+    if (!isRecord(value))
+        return null;
+    if (value.kind === "node" &&
+        hasExactKeys(value, ["kind", "node_ref"]) &&
+        isNonEmptyString(value.node_ref)) {
+        return { kind: "node", node_ref: value.node_ref };
+    }
+    if (value.kind === "exact_session" &&
+        hasExactKeys(value, ["kind", "session_ref"]) &&
+        isNonEmptyString(value.session_ref)) {
+        return { kind: "exact_session", session_ref: value.session_ref };
+    }
+    return null;
+}
+function isCanonicalIsoInstant(value) {
+    const parsed = new Date(value);
+    return Number.isFinite(parsed.getTime()) && parsed.toISOString() === value;
+}
+function isCanonicalIsoInstantValue(value) {
+    return typeof value === "string" && isCanonicalIsoInstant(value);
+}
+export async function emitRuntimeProcessingState(cfg, runtimeKey, event) {
+    const invalidAdapterEvent = validateAdapterProcessingStateEvent(event);
+    if (invalidAdapterEvent) {
+        return {
+            ok: false,
+            terminal: true,
+            detail: invalidAdapterEvent,
+        };
+    }
+    let res;
+    try {
+        res = await apiFetch(cfg, "emit_runtime_processing_state", `${baseUrl(cfg)}/runtime/processing-state`, {
+            method: "POST",
+            headers: jsonHeaders(runtimeKey),
+            body: JSON.stringify(event),
+        });
+    }
+    catch (err) {
+        return transientNetworkOutcome(err);
+    }
+    if (res.status === 204)
+        return { ok: true };
+    if ([401, 403, 409, 422].includes(res.status)) {
+        return terminalHttpOutcome(res);
+    }
+    return transientHttpOutcome(res);
+}
+export async function acquireNodeRecipientMessage(cfg, runtimeKey) {
+    const res = await apiFetch(cfg, "acquire_node_recipient_message", `${baseUrl(cfg)}/runtime/node-recipient/messages/acquire`, {
+        method: "POST",
+        headers: jsonHeaders(runtimeKey),
+        body: JSON.stringify({
+            type: "runtime_node_recipient_message_acquire",
+            version: 1,
+        }),
+    });
+    const raw = await res.json().catch(() => null);
+    if (res.ok || res.status === 409) {
+        return readNodeRecipientMessageAcquireResponse(raw, res.status);
+    }
+    return handleError(res);
+}
+export async function submitNodeRecipientMessageAdmissionEvidence(cfg, runtimeKey, event) {
+    const invalidEvent = validateNodeRecipientMessageAdmissionEvent(event);
+    if (invalidEvent) {
+        return { ok: false, terminal: true, detail: invalidEvent };
+    }
+    let res;
+    try {
+        res = await apiFetch(cfg, "submit_node_recipient_message_admission_evidence", `${baseUrl(cfg)}/runtime/node-recipient/messages/admission-evidence`, {
+            method: "POST",
+            headers: jsonHeaders(runtimeKey),
+            body: JSON.stringify(event),
+        });
+    }
+    catch (error) {
+        return transientNetworkOutcome(error);
+    }
+    if (res.ok) {
+        const body = await res.json().catch(() => null);
+        if (!isRecord(body) ||
+            !hasExactKeys(body, ["type", "version", "status", "admitted_at"]) ||
+            body.type !== "runtime_node_recipient_message_admission_evidence" ||
+            body.version !== 1 ||
+            (body.status !== "admitted" && body.status !== "standing") ||
+            !isNonNegativeInteger(body.admitted_at)) {
+            return invalidWireResponse("invalid_node_recipient_message_admission_response", "invalid node-recipient message admission response");
+        }
+        return {
+            ok: true,
+            status: body.status,
+            admittedAt: body.admitted_at,
+        };
+    }
+    if (res.status === 409 || res.status === 503) {
+        const body = await res.json().catch(() => null);
+        if (!isRecord(body) ||
+            !hasExactKeys(body, [
+                "type",
+                "version",
+                "status",
+                "reason",
+                "retryable",
+            ]) ||
+            body.type !== "runtime_node_recipient_message_admission_evidence" ||
+            body.version !== 1 ||
+            ![
+                "retryable",
+                "attempt_superseded",
+                "message_terminal",
+                "rejected",
+            ].includes(body.status) ||
+            !isNonEmptyString(body.reason) ||
+            !validNodeRecipientMessageAdmissionFailure(body.status, body.reason) ||
+            body.retryable !== (body.status === "retryable") ||
+            (body.status === "retryable" && res.status !== 503) ||
+            (body.status !== "retryable" && res.status !== 409)) {
+            return invalidWireResponse("invalid_node_recipient_message_admission_response", "invalid node-recipient message admission response");
+        }
+        return {
+            ok: false,
+            providerStatus: body.status,
+            reason: body.reason,
+            terminal: body.status !== "retryable",
+            status: res.status,
+        };
+    }
+    if ([401, 403, 422].includes(res.status))
+        return terminalHttpOutcome(res);
+    return transientHttpOutcome(res);
+}
+export async function acquireServicesRetainedNodeRecipientMessage(cfg, runtimeKey, params) {
+    if (!isNonEmptyString(params.endpoint_id) ||
+        !isNonEmptyString(params.endpoint_nonce)) {
+        throw new RuntimeAdapterApiError(422, "invalid_services_retained_node_recipient_acquire", "endpoint_id and endpoint_nonce are required");
+    }
+    const res = await apiFetch(cfg, "acquire_services_retained_node_recipient_message", `${baseUrl(cfg)}/runtime/node-recipient/messages/acquire`, {
+        method: "POST",
+        headers: jsonHeaders(runtimeKey),
+        body: JSON.stringify({
+            type: "runtime_node_recipient_message_acquire",
+            version: 2,
+            endpoint_id: params.endpoint_id,
+            endpoint_nonce: params.endpoint_nonce,
+        }),
+    });
+    const raw = await res.json().catch(() => null);
+    if (res.ok || res.status === 409 || res.status === 503) {
+        return readServicesRetainedNodeRecipientAcquireResponse(raw, res.status);
+    }
+    return handleError(res);
+}
+export async function consumeServicesRetainedNodeRecipientMessage(cfg, runtimeKey, event) {
+    const rawEvent = event;
+    if (!hasExactKeys(rawEvent, [
+        "type",
+        "version",
+        "endpoint_id",
+        "endpoint_nonce",
+        "message_ref",
+        "offer_ref",
+    ]) ||
+        event.type !== "runtime_node_recipient_message_consumption" ||
+        event.version !== 1 ||
+        !isNonEmptyString(event.endpoint_id) ||
+        !isNonEmptyString(event.endpoint_nonce) ||
+        !isNonEmptyString(event.message_ref) ||
+        !isNonEmptyString(event.offer_ref)) {
+        return {
+            ok: false,
+            terminal: true,
+            detail: "services-retained node-recipient consumption does not match the v1 contract",
+        };
+    }
+    let res;
+    try {
+        res = await apiFetch(cfg, "consume_services_retained_node_recipient_message", `${baseUrl(cfg)}/runtime/node-recipient/messages/consumption`, {
+            method: "POST",
+            headers: jsonHeaders(runtimeKey),
+            body: JSON.stringify(event),
+        });
+    }
+    catch (error) {
+        return transientNetworkOutcome(error);
+    }
+    const body = await res.json().catch(() => null);
+    if (res.ok) {
+        if (!isRecord(body) ||
+            !hasExactKeys(body, ["type", "version", "status", "consumed_at"]) ||
+            body.type !== "runtime_node_recipient_message_consumption" ||
+            body.version !== 1 ||
+            (body.status !== "consumed" && body.status !== "standing") ||
+            !isNonNegativeInteger(body.consumed_at)) {
+            return invalidWireResponse("invalid_services_retained_node_recipient_consumption_response", "invalid services-retained node-recipient consumption response");
+        }
+        return {
+            ok: true,
+            status: body.status,
+            consumedAt: body.consumed_at,
+        };
+    }
+    if (res.status === 409 || res.status === 503) {
+        if (!isRecord(body) ||
+            !hasExactKeys(body, [
+                "type",
+                "version",
+                "status",
+                "reason",
+                "retryable",
+            ]) ||
+            body.type !== "runtime_node_recipient_message_consumption" ||
+            body.version !== 1 ||
+            !["retryable", "rejected", "message_terminal"].includes(body.status) ||
+            !isNonEmptyString(body.reason) ||
+            !validServicesRetainedNodeRecipientConsumptionFailure(body.status, body.reason) ||
+            body.retryable !== (body.status === "retryable") ||
+            (body.status === "retryable" && res.status !== 503) ||
+            (body.status !== "retryable" && res.status !== 409)) {
+            return invalidWireResponse("invalid_services_retained_node_recipient_consumption_response", "invalid services-retained node-recipient consumption response");
+        }
+        return {
+            ok: false,
+            providerStatus: body.status,
+            reason: body.reason,
+            terminal: body.status !== "retryable",
+            status: res.status,
+        };
+    }
+    if ([401, 403, 422].includes(res.status))
+        return terminalHttpOutcome(res);
+    return transientHttpOutcome(res);
+}
+export async function acquireExactTargetPresentation(cfg, runtimeKey, params) {
+    const version = params.version ?? 1;
+    const res = await apiFetch(cfg, "acquire_exact_target_presentation", `${baseUrl(cfg)}/runtime/processing-state/presentation-acquire`, {
+        method: "POST",
+        headers: jsonHeaders(runtimeKey),
+        body: JSON.stringify({
+            type: params.eligible_grains !== undefined
+                ? "runtime_exact_target_presentation_filtered_acquire"
+                : "runtime_exact_target_presentation_acquire",
+            version,
+            endpoint_id: params.endpoint_id,
+            endpoint_nonce: params.endpoint_nonce,
+            ...(params.eligible_grains !== undefined && {
+                eligible_grains: params.eligible_grains,
+            }),
+        }),
+    });
+    if (!res.ok)
+        return handleError(res);
+    return readExactTargetPresentationAcquireResponse(await res.json().catch(() => null), version, params.eligible_grains !== undefined);
+}
+export async function submitExactTargetRecipientAdmissionEvidence(cfg, runtimeKey, event) {
+    const invalidEvent = validateExactTargetRecipientAdmissionEvidenceEvent(event);
+    if (invalidEvent) {
+        return {
+            ok: false,
+            terminal: true,
+            detail: invalidEvent,
+        };
+    }
+    let res;
+    try {
+        res = await apiFetch(cfg, "submit_exact_target_recipient_admission_evidence", `${baseUrl(cfg)}/runtime/processing-state/recipient-admission-evidence`, {
+            method: "POST",
+            headers: jsonHeaders(runtimeKey),
+            body: JSON.stringify(event),
+        });
+    }
+    catch (err) {
+        return transientNetworkOutcome(err);
+    }
+    if (res.ok) {
+        const body = (await res.json().catch(() => null));
+        if (body?.type !== "runtime_exact_target_recipient_admission_evidence" ||
+            body.version !== 1 ||
+            (body.status !== "admitted" && body.status !== "standing") ||
+            !isNonNegativeInteger(body.admitted_at)) {
+            return invalidWireResponse("invalid_exact_target_recipient_admission_response", "invalid exact-target recipient-admission response");
+        }
+        return {
+            ok: true,
+            status: body.status,
+            admittedAt: body.admitted_at,
+        };
+    }
+    if (res.status === 409 || res.status === 503) {
+        const body = (await res.json().catch(() => null));
+        if (body?.type !== "runtime_exact_target_recipient_admission_evidence" ||
+            body.version !== 1 ||
+            ![
+                "retryable",
+                "attempt_superseded",
+                "message_terminal",
+                "rejected",
+            ].includes(body.status) ||
+            !isNonEmptyString(body.reason) ||
+            !validExactTargetRecipientAdmissionFailure(body.status, body.reason) ||
+            body.retryable !== (body.status === "retryable") ||
+            (body.status === "retryable" && res.status !== 503) ||
+            (body.status !== "retryable" && res.status !== 409)) {
+            return invalidWireResponse("invalid_exact_target_recipient_admission_response", "invalid exact-target recipient-admission response");
+        }
+        return {
+            ok: false,
+            providerStatus: body.status,
+            reason: body.reason,
+            terminal: body.status !== "retryable",
+            status: res.status,
+        };
+    }
+    if ([401, 403, 422].includes(res.status)) {
+        return terminalHttpOutcome(res);
+    }
+    return transientHttpOutcome(res);
+}
+export async function submitExactTargetPresentationEvidence(cfg, runtimeKey, event) {
+    const invalidEvent = validateExactTargetPresentationEvidenceEvent(event);
+    if (invalidEvent) {
+        return {
+            ok: false,
+            terminal: true,
+            detail: invalidEvent,
+        };
+    }
+    let res;
+    try {
+        res = await apiFetch(cfg, "submit_exact_target_presentation_evidence", `${baseUrl(cfg)}/runtime/processing-state/presentation-evidence`, {
+            method: "POST",
+            headers: jsonHeaders(runtimeKey),
+            body: JSON.stringify(event),
+        });
+    }
+    catch (err) {
+        return transientNetworkOutcome(err);
+    }
+    if (res.status === 204)
+        return { ok: true };
+    if ([401, 403, 409, 422].includes(res.status)) {
+        return terminalHttpOutcome(res);
+    }
+    return transientHttpOutcome(res);
+}
+export async function releaseExactTargetPresentation(cfg, runtimeKey, event) {
+    let res;
+    try {
+        res = await apiFetch(cfg, "release_exact_target_presentation", `${baseUrl(cfg)}/runtime/processing-state/presentation-release`, {
+            method: "POST",
+            headers: jsonHeaders(runtimeKey),
+            body: JSON.stringify(event),
+        });
+    }
+    catch (err) {
+        return transientNetworkOutcome(err);
+    }
+    if (res.ok) {
+        const body = (await res.json().catch(() => null));
+        return { ok: true, released: body?.released === true };
+    }
+    if ([401, 403, 409, 422].includes(res.status)) {
+        return terminalHttpOutcome(res);
+    }
+    return transientHttpOutcome(res);
+}
+function getFetch(cfg) {
+    return cfg.fetch ?? fetch;
+}
+async function apiFetch(cfg, requestKind, url, init = {}) {
+    const timeoutMs = requestTimeoutMs(cfg, requestKind);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await getFetch(cfg)(url, { ...init, signal: controller.signal });
+    }
+    catch (err) {
+        throw toNetworkError(err, requestKind, timeoutMs);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function requestTimeoutMs(cfg, requestKind) {
+    const override = cfg.requestTimeoutMs?.[requestKind];
+    if (override !== undefined && Number.isFinite(override) && override > 0) {
+        return override;
+    }
+    return DEFAULT_REQUEST_TIMEOUT_MS[requestKind];
+}
+function toNetworkError(err, requestKind, timeoutMs) {
+    if (err instanceof Error && err.name === "AbortError") {
+        return new RuntimeAdapterNetworkError("timeout", `timed out after ${timeoutMs}ms`, requestKind);
+    }
+    if (err instanceof TypeError && err.message === "fetch failed") {
+        const cause = err.cause;
+        const code = causeCode(cause);
+        const detail = cause instanceof Error && cause.message
+            ? cause.message
+            : code || "fetch failed";
+        return new RuntimeAdapterNetworkError(isTimeoutCode(code) ? "timeout" : "network", detail, requestKind);
+    }
+    return err;
+}
+function causeCode(cause) {
+    if (cause && typeof cause === "object" && "code" in cause) {
+        const code = cause.code;
+        if (typeof code === "string")
+            return code;
+    }
+    return "";
+}
+function isTimeoutCode(code) {
+    return (code === "ETIMEDOUT" ||
+        code === "UND_ERR_CONNECT_TIMEOUT" ||
+        code === "UND_ERR_HEADERS_TIMEOUT" ||
+        code === "UND_ERR_BODY_TIMEOUT");
+}
+function baseUrl(cfg) {
+    const trimmed = cfg.apiHost.replace(/\/+$/, "");
+    const origin = /^https?:\/\//.test(trimmed) ? trimmed : `https://${trimmed}`;
+    return `${origin}/v1`;
+}
+async function handleError(res) {
+    const error = await readErrorEnvelope(res);
+    throw new RuntimeAdapterApiError(res.status, error.code ?? "unknown", error.message ?? res.statusText);
+}
+function authHeaders(runtimeKey) {
+    return { Authorization: `Bearer ${runtimeKey}` };
+}
+function jsonHeaders(runtimeKey) {
+    return {
+        ...authHeaders(runtimeKey),
+        "Content-Type": "application/json",
+    };
+}
+function targetMessagingHeaders(runtimeKey) {
+    return {
+        ...authHeaders(runtimeKey),
+        Accept: TARGET_MESSAGING_MEDIA_TYPE,
+        "Content-Type": TARGET_MESSAGING_MEDIA_TYPE,
+    };
+}
+function targetMessagingReadHeaders(runtimeKey) {
+    return {
+        ...authHeaders(runtimeKey),
+        Accept: TARGET_MESSAGING_MEDIA_TYPE,
+    };
+}
+function endpointReadHeaders(runtimeKey, options) {
+    return {
+        ...authHeaders(runtimeKey),
+        ...(options.endpointNonce !== undefined && {
+            "X-Endpoint-Nonce": options.endpointNonce,
+        }),
+    };
+}
+function validateAdapterProcessingStateEvent(event) {
+    if (!isRecord(event))
+        return "processing-state event must be an object";
+    const raw = event;
+    if (raw.type !== undefined && raw.type !== "runtime_processing_state") {
+        return 'type must be "runtime_processing_state"';
+    }
+    if (raw.version !== undefined && raw.version !== 1) {
+        return "version must be 1";
+    }
+    if (raw.agent_id !== undefined && !isNonEmptyString(raw.agent_id)) {
+        return "agent_id must be a non-empty string";
+    }
+    if (!isNonEmptyString(raw.source_message_id)) {
+        return "source_message_id must be a non-empty string";
+    }
+    if (!isNonEmptyString(raw.assignment_id)) {
+        return "assignment_id must be a non-empty string";
+    }
+    if (!isNonEmptyString(raw.state_event_id)) {
+        return "state_event_id must be a non-empty string";
+    }
+    if (!isPositiveInteger(raw.state_sequence)) {
+        return "state_sequence must be a positive integer";
+    }
+    if (parseRuntimeWorkTargetRef(raw.target_ref) === null) {
+        return "target_ref must be a valid RuntimeWorkTargetRef";
+    }
+    if (!ADAPTER_RUNTIME_PROCESSING_STATES.includes(raw.state)) {
+        return `state is not adapter-emittable: ${String(raw.state)}`;
+    }
+    if (!isUnixMs(raw.occurred_at)) {
+        return "occurred_at must be a unix timestamp in milliseconds";
+    }
+    if (raw.undispatched_id !== undefined &&
+        !isNonEmptyString(raw.undispatched_id)) {
+        return "undispatched_id must be a non-empty string";
+    }
+    if (raw.retryable !== undefined && typeof raw.retryable !== "boolean") {
+        return "retryable must be a boolean";
+    }
+    if (raw.state === "processing_failed" && raw.retryable === undefined) {
+        return "retryable is required for processing_failed";
+    }
+    if (raw.reason_code !== undefined && !isNonEmptyString(raw.reason_code)) {
+        return "reason_code must be a non-empty string";
+    }
+    if (raw.state === "waiting_for_runtime_capability" &&
+        raw.reason_code === undefined) {
+        return "reason_code is required for waiting_for_runtime_capability";
+    }
+    if (raw.detail !== undefined && typeof raw.detail !== "string") {
+        return "detail must be a string";
+    }
+    if ("reply_request_id" in raw ||
+        "outbound_message_id" in raw ||
+        "broker_projection_token" in raw) {
+        return "adapter processing-state events must not carry reply or broker projection fields";
+    }
+    return undefined;
+}
+function validateExactTargetPresentationEvidenceEvent(event) {
+    if (!isRecord(event))
+        return "presentation evidence event must be an object";
+    const raw = event;
+    for (const field of [
+        "state_event_id",
+        "state_sequence",
+        "state",
+        "occurred_at",
+        "undispatched_id",
+        "retryable",
+        "reason_code",
+        "detail",
+        "reply_request_id",
+        "outbound_message_id",
+        "broker_projection_token",
+    ]) {
+        if (raw[field] !== undefined) {
+            return `presentation evidence event must not include ${field}`;
+        }
+    }
+    if (raw.type !== "runtime_exact_target_presentation_evidence") {
+        return 'type must be "runtime_exact_target_presentation_evidence"';
+    }
+    if (raw.version !== 1) {
+        return "version must be 1";
+    }
+    if (!isNonEmptyString(raw.source_message_id)) {
+        return "source_message_id must be a non-empty string";
+    }
+    if (!isNonEmptyString(raw.endpoint_id)) {
+        return "endpoint_id must be a non-empty string";
+    }
+    if (!isNonEmptyString(raw.endpoint_nonce)) {
+        return "endpoint_nonce must be a non-empty string";
+    }
+    if (!isNonEmptyString(raw.assignment_id)) {
+        return "assignment_id must be a non-empty string";
+    }
+    if (parseRuntimeWorkTargetRef(raw.target_ref) === null) {
+        return "target_ref must be a valid RuntimeWorkTargetRef";
+    }
+    if (!isNonEmptyString(raw.presentation_confirmation_token) ||
+        !/^etp1_[A-Za-z0-9_-]{43}$/.test(raw.presentation_confirmation_token)) {
+        return "presentation_confirmation_token must be a valid v1 token";
+    }
+    if (!isRecord(raw.presentation_evidence)) {
+        return "presentation_evidence must be an object";
+    }
+    const evidence = raw.presentation_evidence;
+    if (evidence.version !== 1 ||
+        !["full", "partial", "pointer_only"].includes(evidence.disposition) ||
+        !isNonEmptyString(evidence.evidence_contract_id) ||
+        !isNonNegativeInteger(evidence.evidence_contract_generation) ||
+        !isNonEmptyString(evidence.envelope_digest) ||
+        !/^[A-Za-z0-9_-]{43}$/.test(evidence.envelope_digest) ||
+        !isNonEmptyString(evidence.role) ||
+        !isNonEmptyString(evidence.boundary_kind) ||
+        !isNonEmptyString(evidence.boundary_ref) ||
+        !isNonNegativeInteger(evidence.boundary_position) ||
+        !isNonEmptyString(evidence.authority_incarnation) ||
+        !isNonNegativeInteger(evidence.authority_sequence) ||
+        !isUnixMs(evidence.observed_at)) {
+        return "presentation_evidence does not match the v1 contract";
+    }
+    return undefined;
+}
+function validateExactTargetRecipientAdmissionEvidenceEvent(event) {
+    if (!isRecord(event)) {
+        return "recipient admission evidence event must be an object";
+    }
+    const raw = event;
+    if (raw.type !== "runtime_exact_target_recipient_admission_evidence") {
+        return 'type must be "runtime_exact_target_recipient_admission_evidence"';
+    }
+    if (raw.version !== 1)
+        return "version must be 1";
+    if (!isNonEmptyString(raw.endpoint_id)) {
+        return "endpoint_id must be a non-empty string";
+    }
+    if (!isNonEmptyString(raw.endpoint_nonce)) {
+        return "endpoint_nonce must be a non-empty string";
+    }
+    if (!isNonEmptyString(raw.source_message_id)) {
+        return "source_message_id must be a non-empty string";
+    }
+    if (!isNonEmptyString(raw.assignment_id)) {
+        return "assignment_id must be a non-empty string";
+    }
+    if (parseRuntimeWorkTargetRef(raw.target_ref) === null) {
+        return "target_ref must be a valid RuntimeWorkTargetRef";
+    }
+    if (!isNonEmptyString(raw.presentation_confirmation_token) ||
+        !/^etp1_[A-Za-z0-9_-]{43}$/.test(raw.presentation_confirmation_token)) {
+        return "presentation_confirmation_token must be a valid v1 token";
+    }
+    if (!isRecord(raw.recipient_admission_evidence)) {
+        return "recipient_admission_evidence must be an object";
+    }
+    const evidence = raw.recipient_admission_evidence;
+    if (evidence.version !== 1 ||
+        !isNonEmptyString(evidence.evidence_contract_id) ||
+        !isNonNegativeInteger(evidence.evidence_contract_generation) ||
+        typeof evidence.envelope_digest !== "string" ||
+        !/^[A-Za-z0-9_-]{43}$/.test(evidence.envelope_digest) ||
+        !isNonEmptyString(evidence.authority_incarnation) ||
+        evidence.authority_sequence !== 1) {
+        return "recipient_admission_evidence does not match the v1 contract";
+    }
+    return undefined;
+}
+function validateNodeRecipientMessageAdmissionEvent(event) {
+    if (!isRecord(event)) {
+        return "node-recipient message admission event must be an object";
+    }
+    const raw = event;
+    if (!hasExactKeys(raw, [
+        "type",
+        "version",
+        "message_ref",
+        "offer_ref",
+        "confirmation_token",
+        "recipient_admission_evidence",
+    ]) ||
+        raw.type !== "runtime_node_recipient_message_admission_evidence" ||
+        raw.version !== 1 ||
+        !isNonEmptyString(raw.message_ref) ||
+        !isNonEmptyString(raw.offer_ref) ||
+        !isNonEmptyString(raw.confirmation_token) ||
+        !/^etp1_[A-Za-z0-9_-]{43}$/.test(raw.confirmation_token) ||
+        !isRecord(raw.recipient_admission_evidence)) {
+        return "node-recipient message admission event does not match the v1 contract";
+    }
+    const evidence = raw.recipient_admission_evidence;
+    if (!hasExactKeys(evidence, [
+        "version",
+        "evidence_contract_id",
+        "evidence_contract_generation",
+        "envelope_digest",
+        "authority_incarnation",
+        "authority_sequence",
+    ]) ||
+        evidence.version !== 1 ||
+        !isNonEmptyString(evidence.evidence_contract_id) ||
+        !isNonNegativeInteger(evidence.evidence_contract_generation) ||
+        typeof evidence.envelope_digest !== "string" ||
+        !/^[A-Za-z0-9_-]{43}$/.test(evidence.envelope_digest) ||
+        !isNonEmptyString(evidence.authority_incarnation) ||
+        evidence.authority_sequence !== 1) {
+        return "recipient_admission_evidence does not match the v1 contract";
+    }
+    return undefined;
+}
+function validNodeRecipientMessageAdmissionFailure(status, reason) {
+    switch (status) {
+        case "retryable":
+            return reason === "processing_conflict";
+        case "attempt_superseded":
+            return ["attempt_missing", "attempt_expired"].includes(reason);
+        case "message_terminal":
+            return reason === "message_terminal";
+        case "rejected":
+            return [
+                "invalid_input",
+                "attempt_conflict",
+                "target_mismatch",
+                "evidence_conflict",
+            ].includes(reason);
+        default:
+            return false;
+    }
+}
+function validServicesRetainedNodeRecipientConsumptionFailure(status, reason) {
+    switch (status) {
+        case "retryable":
+            return ["endpoint_unavailable", "processing_conflict"].includes(reason);
+        case "message_terminal":
+            return reason === "message_terminal";
+        case "rejected":
+            return [
+                "invalid_input",
+                "node_addressing_class_unavailable",
+                "capability_missing",
+                "attempt_missing",
+                "attempt_conflict",
+                "target_mismatch",
+            ].includes(reason);
+        default:
+            return false;
+    }
+}
+function validExactTargetRecipientAdmissionFailure(status, reason) {
+    switch (status) {
+        case "retryable":
+            return ["endpoint_unavailable", "processing_conflict"].includes(reason);
+        case "attempt_superseded":
+            return ["attempt_missing", "attempt_expired"].includes(reason);
+        case "message_terminal":
+            return reason === "message_terminal";
+        case "rejected":
+            return [
+                "invalid_input",
+                "source_missing",
+                "attempt_conflict",
+                "target_mismatch",
+                "evidence_conflict",
+            ].includes(reason);
+        default:
+            return false;
+    }
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isPositiveInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function isNonNegativeInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isUnixMs(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function readRemoteMessageEnvelope(raw, expectedMessageRef) {
+    if (!isRecord(raw) ||
+        !hasExactKeys(raw, [
+            "type",
+            "sender",
+            "message_ref",
+            "content",
+            ...(raw.sent_at === undefined ? [] : ["sent_at"]),
+        ]) ||
+        raw.type !== "masons.remote_message.v1" ||
+        !isRecord(raw.sender) ||
+        !hasExactKeys(raw.sender, [
+            ...(raw.sender.display_name === undefined ? [] : ["display_name"]),
+            ...(raw.sender.handle === undefined ? [] : ["handle"]),
+        ]) ||
+        !isNonEmptyString(raw.message_ref) ||
+        (expectedMessageRef !== undefined &&
+            raw.message_ref !== expectedMessageRef) ||
+        typeof raw.content !== "string" ||
+        (raw.sender.display_name !== undefined &&
+            typeof raw.sender.display_name !== "string") ||
+        (raw.sender.handle !== undefined &&
+            typeof raw.sender.handle !== "string") ||
+        (raw.sent_at !== undefined && !isCanonicalIsoInstantValue(raw.sent_at))) {
+        return null;
+    }
+    return {
+        type: "masons.remote_message.v1",
+        sender: {
+            ...(typeof raw.sender.display_name === "string" && {
+                display_name: raw.sender.display_name,
+            }),
+            ...(typeof raw.sender.handle === "string" && {
+                handle: raw.sender.handle,
+            }),
+        },
+        message_ref: raw.message_ref,
+        content: raw.content,
+        ...(typeof raw.sent_at === "string" && { sent_at: raw.sent_at }),
+    };
+}
+function readNodeRecipientMessageAcquireResponse(raw, httpStatus) {
+    const invalid = () => invalidWireResponse("invalid_node_recipient_message_acquire_response", "invalid node-recipient message acquire response");
+    if (!isRecord(raw) ||
+        raw.type !== "runtime_node_recipient_message_acquire" ||
+        raw.version !== 1) {
+        return invalid();
+    }
+    if (raw.status === "empty" &&
+        httpStatus === 200 &&
+        hasExactKeys(raw, ["type", "version", "status"])) {
+        return {
+            type: "runtime_node_recipient_message_acquire",
+            version: 1,
+            status: "empty",
+        };
+    }
+    if (raw.status === "rejected" &&
+        httpStatus === 409 &&
+        raw.reason === "node_addressing_class_unavailable" &&
+        raw.retryable === false &&
+        hasExactKeys(raw, ["type", "version", "status", "reason", "retryable"])) {
+        return {
+            type: "runtime_node_recipient_message_acquire",
+            version: 1,
+            status: "rejected",
+            reason: "node_addressing_class_unavailable",
+            retryable: false,
+        };
+    }
+    const envelope = readRemoteMessageEnvelope(raw.envelope, raw.message_ref);
+    if (httpStatus !== 200 ||
+        (raw.status !== "offered" && raw.status !== "standing") ||
+        !hasExactKeys(raw, [
+            "type",
+            "version",
+            "status",
+            "message_ref",
+            "offer_ref",
+            "confirmation_token",
+            "recipient_admission_contract",
+            "evidence_authority_incarnation",
+            "content_type",
+            "envelope_digest",
+            "offered_at",
+            "expires_at",
+            "envelope",
+        ]) ||
+        !isNonEmptyString(raw.message_ref) ||
+        !isNonEmptyString(raw.offer_ref) ||
+        !isNonEmptyString(raw.confirmation_token) ||
+        !/^etp1_[A-Za-z0-9_-]{43}$/.test(raw.confirmation_token) ||
+        !isRecord(raw.recipient_admission_contract) ||
+        !hasExactKeys(raw.recipient_admission_contract, ["id", "generation"]) ||
+        !isNonEmptyString(raw.recipient_admission_contract.id) ||
+        !isNonNegativeInteger(raw.recipient_admission_contract.generation) ||
+        !isNonEmptyString(raw.evidence_authority_incarnation) ||
+        !isNonEmptyString(raw.content_type) ||
+        typeof raw.envelope_digest !== "string" ||
+        !/^[A-Za-z0-9_-]{43}$/.test(raw.envelope_digest) ||
+        !isCanonicalIsoInstantValue(raw.offered_at) ||
+        !isCanonicalIsoInstantValue(raw.expires_at) ||
+        Date.parse(raw.offered_at) >= Date.parse(raw.expires_at) ||
+        envelope === null) {
+        return invalid();
+    }
+    return {
+        type: "runtime_node_recipient_message_acquire",
+        version: 1,
+        status: raw.status,
+        message_ref: raw.message_ref,
+        offer_ref: raw.offer_ref,
+        confirmation_token: raw.confirmation_token,
+        recipient_admission_contract: {
+            id: raw.recipient_admission_contract.id,
+            generation: raw.recipient_admission_contract.generation,
+        },
+        evidence_authority_incarnation: raw.evidence_authority_incarnation,
+        content_type: raw.content_type,
+        envelope_digest: raw.envelope_digest,
+        offered_at: raw.offered_at,
+        expires_at: raw.expires_at,
+        envelope,
+    };
+}
+function readServicesRetainedNodeRecipientAcquireResponse(raw, httpStatus) {
+    const invalid = () => invalidWireResponse("invalid_services_retained_node_recipient_acquire_response", "invalid services-retained node-recipient acquire response");
+    if (!isRecord(raw) ||
+        raw.type !== "runtime_node_recipient_message_acquire" ||
+        raw.version !== 2) {
+        return invalid();
+    }
+    if (raw.status === "empty" &&
+        httpStatus === 200 &&
+        hasExactKeys(raw, ["type", "version", "status"])) {
+        return {
+            type: "runtime_node_recipient_message_acquire",
+            version: 2,
+            status: "empty",
+        };
+    }
+    if (raw.status === "rejected") {
+        const reason = raw.reason;
+        const retryable = reason === "endpoint_unavailable";
+        if (![
+            "node_addressing_class_unavailable",
+            "endpoint_unavailable",
+            "capability_missing",
+            "message_terminal",
+        ].includes(reason) ||
+            raw.retryable !== retryable ||
+            httpStatus !== (retryable ? 503 : 409) ||
+            !hasExactKeys(raw, ["type", "version", "status", "reason", "retryable"])) {
+            return invalid();
+        }
+        return {
+            type: "runtime_node_recipient_message_acquire",
+            version: 2,
+            status: "rejected",
+            reason: reason,
+            retryable,
+        };
+    }
+    const envelope = readRemoteMessageEnvelope(raw.envelope, raw.message_ref);
+    if (httpStatus !== 200 ||
+        raw.status !== "retained" ||
+        !hasExactKeys(raw, [
+            "type",
+            "version",
+            "status",
+            "message_ref",
+            "offer_ref",
+            "recipient_admission_contract",
+            "content_type",
+            "envelope_digest",
+            "retained_at",
+            "envelope",
+        ]) ||
+        !isNonEmptyString(raw.message_ref) ||
+        !isNonEmptyString(raw.offer_ref) ||
+        !isRecord(raw.recipient_admission_contract) ||
+        !hasExactKeys(raw.recipient_admission_contract, ["id", "generation"]) ||
+        raw.recipient_admission_contract.id !==
+            "target-node-recipient-services-retained-v1" ||
+        raw.recipient_admission_contract.generation !== 1 ||
+        !isNonEmptyString(raw.content_type) ||
+        typeof raw.envelope_digest !== "string" ||
+        !/^[A-Za-z0-9_-]{43}$/.test(raw.envelope_digest) ||
+        !isCanonicalIsoInstantValue(raw.retained_at) ||
+        envelope === null) {
+        return invalid();
+    }
+    return {
+        type: "runtime_node_recipient_message_acquire",
+        version: 2,
+        status: "retained",
+        message_ref: raw.message_ref,
+        offer_ref: raw.offer_ref,
+        recipient_admission_contract: {
+            id: "target-node-recipient-services-retained-v1",
+            generation: 1,
+        },
+        content_type: raw.content_type,
+        envelope_digest: raw.envelope_digest,
+        retained_at: raw.retained_at,
+        envelope,
+    };
+}
+function readExactTargetPresentationAcquireResponse(raw, expectedVersion, filtered = false) {
+    const invalid = () => invalidWireResponse("invalid_exact_target_presentation_acquire_response", "invalid exact-target presentation acquire response");
+    const expectedType = filtered
+        ? "runtime_exact_target_presentation_filtered_acquire"
+        : "runtime_exact_target_presentation_acquire";
+    if (!isRecord(raw) ||
+        raw.type !== expectedType ||
+        raw.version !== expectedVersion) {
+        return invalid();
+    }
+    if (raw.status === "empty") {
+        return {
+            type: "runtime_exact_target_presentation_acquire",
+            version: expectedVersion,
+            status: "empty",
+        };
+    }
+    const envelope = readRemoteMessageEnvelope(raw.envelope);
+    if ((raw.status !== "bound" && raw.status !== "standing") ||
+        !isNonEmptyString(raw.source_message_id) ||
+        !isNonEmptyString(raw.assignment_id) ||
+        !isNonEmptyString(raw.confirmation_token) ||
+        !/^etp1_[A-Za-z0-9_-]{43}$/.test(raw.confirmation_token) ||
+        !isRecord(raw.evidence_contract) ||
+        !isNonEmptyString(raw.evidence_contract.id) ||
+        !isNonNegativeInteger(raw.evidence_contract.generation) ||
+        !isNonEmptyString(raw.evidence_contract.role) ||
+        !isNonEmptyString(raw.evidence_contract.boundary_kind) ||
+        !isNonEmptyString(raw.evidence_authority_incarnation) ||
+        !isNonEmptyString(raw.content_type) ||
+        typeof raw.envelope_digest !== "string" ||
+        !/^[A-Za-z0-9_-]{43}$/.test(raw.envelope_digest) ||
+        !isNonEmptyString(raw.assigned_at) ||
+        Number.isNaN(Date.parse(raw.assigned_at)) ||
+        !isNonEmptyString(raw.expires_at) ||
+        Number.isNaN(Date.parse(raw.expires_at)) ||
+        (expectedVersion === 1 && raw.recipient_admission_contract !== undefined) ||
+        (expectedVersion === 2 &&
+            (!isRecord(raw.recipient_admission_contract) ||
+                !isNonEmptyString(raw.recipient_admission_contract.id) ||
+                !isNonNegativeInteger(raw.recipient_admission_contract.generation))) ||
+        envelope === null) {
+        return invalid();
+    }
+    const targetRef = parseRuntimeWorkTargetRef(raw.target_ref);
+    if (targetRef === null)
+        return invalid();
+    const response = {
+        type: "runtime_exact_target_presentation_acquire",
+        status: raw.status,
+        source_message_id: raw.source_message_id,
+        assignment_id: raw.assignment_id,
+        target_ref: targetRef,
+        confirmation_token: raw.confirmation_token,
+        evidence_contract: {
+            id: raw.evidence_contract.id,
+            generation: raw.evidence_contract.generation,
+            role: raw.evidence_contract.role,
+            boundary_kind: raw.evidence_contract.boundary_kind,
+        },
+        evidence_authority_incarnation: raw.evidence_authority_incarnation,
+        content_type: raw.content_type,
+        envelope_digest: raw.envelope_digest,
+        assigned_at: raw.assigned_at,
+        expires_at: raw.expires_at,
+        envelope,
+    };
+    if (expectedVersion === 1)
+        return { ...response, version: 1 };
+    if (!isRecord(raw.recipient_admission_contract))
+        return invalid();
+    return {
+        ...response,
+        version: 2,
+        recipient_admission_contract: {
+            id: raw.recipient_admission_contract.id,
+            generation: raw.recipient_admission_contract.generation,
+        },
+    };
+}
+function readRegisterRuntimeEndpointResponse(raw) {
+    if (!isRecord(raw)) {
+        return invalidWireResponse("invalid_register_runtime_endpoint_response", "invalid runtime endpoint registration response");
+    }
+    if (typeof raw.endpoint_id !== "string" ||
+        typeof raw.node_id !== "string" ||
+        typeof raw.display_label !== "string" ||
+        typeof raw.heartbeat_after_seconds !== "number" ||
+        typeof raw.lease_ttl_seconds !== "number" ||
+        typeof raw.soft_retention_seconds !== "number" ||
+        typeof raw.registered_at !== "string") {
+        return invalidWireResponse("invalid_register_runtime_endpoint_response", "invalid runtime endpoint registration response");
+    }
+    const runtimeCapabilities = readOptionalStringArray(raw.runtime_capabilities);
+    const sessionNaming = raw.session_naming === undefined
+        ? undefined
+        : parseRuntimeSessionNaming(raw.session_naming);
+    if (runtimeCapabilities === null ||
+        sessionNaming === null ||
+        (raw.execution_surface !== undefined &&
+            typeof raw.execution_surface !== "string") ||
+        (raw.background_exchange_mode !== undefined &&
+            typeof raw.background_exchange_mode !== "string") ||
+        (raw.natural_boundary_presentation_contract_id !== undefined &&
+            typeof raw.natural_boundary_presentation_contract_id !== "string") ||
+        (raw.node_recipient_admission_contract_id !== undefined &&
+            typeof raw.node_recipient_admission_contract_id !== "string")) {
+        return invalidWireResponse("invalid_register_runtime_endpoint_response", "invalid runtime endpoint registration response");
+    }
+    return {
+        endpoint_id: raw.endpoint_id,
+        node_id: raw.node_id,
+        display_label: raw.display_label,
+        ...(sessionNaming !== undefined && { session_naming: sessionNaming }),
+        ...(runtimeCapabilities !== undefined && {
+            runtime_capabilities: runtimeCapabilities,
+        }),
+        ...(typeof raw.execution_surface === "string" && {
+            execution_surface: raw.execution_surface,
+        }),
+        ...(typeof raw.background_exchange_mode === "string" && {
+            background_exchange_mode: raw.background_exchange_mode,
+        }),
+        ...(typeof raw.natural_boundary_presentation_contract_id === "string" && {
+            natural_boundary_presentation_contract_id: raw.natural_boundary_presentation_contract_id,
+        }),
+        ...(typeof raw.node_recipient_admission_contract_id === "string" && {
+            node_recipient_admission_contract_id: raw.node_recipient_admission_contract_id,
+        }),
+        heartbeat_after_seconds: raw.heartbeat_after_seconds,
+        lease_ttl_seconds: raw.lease_ttl_seconds,
+        soft_retention_seconds: raw.soft_retention_seconds,
+        registered_at: raw.registered_at,
+    };
+}
+function readListOwnedRuntimeEndpointsResponse(raw) {
+    const rawItems = isRecord(raw) && Array.isArray(raw.items)
+        ? raw.items
+        : isRecord(raw) && Array.isArray(raw.endpoints)
+            ? raw.endpoints
+            : null;
+    if (!isRecord(raw) || !isNonNegativeInteger(raw.total) || rawItems === null) {
+        return invalidWireResponse("invalid_list_runtime_endpoints_response", "invalid runtime endpoint list response");
+    }
+    return {
+        total: raw.total,
+        items: rawItems.map((item) => readOwnedRuntimeEndpointView(item)),
+    };
+}
+function readOwnedRuntimeEndpointView(raw) {
+    if (!isRecord(raw)) {
+        return invalidWireResponse("invalid_runtime_endpoint_view", "invalid runtime endpoint view");
+    }
+    if (typeof raw.endpoint_id !== "string" ||
+        typeof raw.node_id !== "string" ||
+        typeof raw.runtime_kind !== "string" ||
+        typeof raw.display_label !== "string" ||
+        typeof raw.registered_at !== "string" ||
+        typeof raw.is_self !== "boolean") {
+        return invalidWireResponse("invalid_runtime_endpoint_view", "invalid runtime endpoint view");
+    }
+    const runtimeCapabilities = readOptionalStringArray(raw.runtime_capabilities);
+    const runtimeSessionId = typeof raw.runtime_session_id === "string"
+        ? raw.runtime_session_id
+        : undefined;
+    const runtimeSessionIdentityKey = raw.runtime_session_identity_key === undefined
+        ? undefined
+        : parseRuntimeSessionIdentityKey(raw.runtime_session_identity_key);
+    const runtimeSessionDisplay = raw.runtime_session_display === undefined
+        ? undefined
+        : parseRuntimeSessionDisplayMetadata(raw.runtime_session_display);
+    const sessionNaming = raw.session_naming === undefined
+        ? undefined
+        : parseRuntimeSessionNaming(raw.session_naming);
+    const workTarget = raw.runtime_work_target_ref === undefined
+        ? undefined
+        : parseRuntimeWorkTargetRef(raw.runtime_work_target_ref);
+    if (runtimeCapabilities === null || sessionNaming === null) {
+        return invalidWireResponse("invalid_runtime_endpoint_view", "invalid runtime endpoint view");
+    }
+    if (raw.runtime_session_identity_key !== undefined &&
+        runtimeSessionIdentityKey === null) {
+        return invalidWireResponse("invalid_runtime_endpoint_view", "invalid runtime endpoint view");
+    }
+    if (raw.runtime_session_display !== undefined &&
+        runtimeSessionDisplay === null) {
+        return invalidWireResponse("invalid_runtime_endpoint_view", "invalid runtime endpoint view");
+    }
+    const validRuntimeSessionIdentityKey = runtimeSessionIdentityKey === null ? undefined : runtimeSessionIdentityKey;
+    const validRuntimeSessionDisplay = runtimeSessionDisplay === null ? undefined : runtimeSessionDisplay;
+    if (validRuntimeSessionDisplay !== undefined &&
+        isRuntimeDebugIdentifierTitle(validRuntimeSessionDisplay.title, [
+            raw.endpoint_id,
+            runtimeSessionId,
+            validRuntimeSessionIdentityKey,
+        ])) {
+        return invalidWireResponse("invalid_runtime_endpoint_view", "invalid runtime endpoint view");
+    }
+    if (raw.runtime_work_target_ref !== undefined && workTarget === null) {
+        return invalidWireResponse("invalid_runtime_endpoint_view", "invalid runtime endpoint view");
+    }
+    const runtimeWorkTarget = workTarget === null ? undefined : workTarget;
+    return {
+        endpoint_id: raw.endpoint_id,
+        node_id: raw.node_id,
+        ...(typeof raw.node_handle === "string" && {
+            node_handle: raw.node_handle,
+        }),
+        runtime_kind: raw.runtime_kind,
+        ...(runtimeSessionId !== undefined && {
+            runtime_session_id: runtimeSessionId,
+        }),
+        ...(validRuntimeSessionIdentityKey !== undefined && {
+            runtime_session_identity_key: validRuntimeSessionIdentityKey,
+        }),
+        display_label: raw.display_label,
+        ...(typeof raw.session_name === "string" && {
+            session_name: raw.session_name,
+        }),
+        ...(typeof raw.task_hint === "string" && { task_hint: raw.task_hint }),
+        ...(sessionNaming !== undefined && { session_naming: sessionNaming }),
+        ...(validRuntimeSessionDisplay !== undefined && {
+            runtime_session_display: validRuntimeSessionDisplay,
+        }),
+        ...(isWorkspaceMetadata(raw.workspace) && { workspace: raw.workspace }),
+        ...(typeof raw.tracking_ref === "string" && {
+            tracking_ref: raw.tracking_ref,
+        }),
+        ...(isEndpointFingerprint(raw.fingerprint) && {
+            fingerprint: raw.fingerprint,
+        }),
+        ...(runtimeCapabilities !== undefined && {
+            runtime_capabilities: runtimeCapabilities,
+        }),
+        ...(typeof raw.execution_surface === "string" && {
+            execution_surface: raw.execution_surface,
+        }),
+        ...(typeof raw.background_exchange_mode === "string" && {
+            background_exchange_mode: raw.background_exchange_mode,
+        }),
+        ...(typeof raw.natural_boundary_presentation_contract_id === "string" && {
+            natural_boundary_presentation_contract_id: raw.natural_boundary_presentation_contract_id,
+        }),
+        ...(typeof raw.node_recipient_admission_contract_id === "string" && {
+            node_recipient_admission_contract_id: raw.node_recipient_admission_contract_id,
+        }),
+        ...(runtimeWorkTarget !== undefined && {
+            runtime_work_target_ref: runtimeWorkTarget,
+        }),
+        registered_at: raw.registered_at,
+        ...(typeof raw.retired_at === "string" && { retired_at: raw.retired_at }),
+        is_self: raw.is_self,
+    };
+}
+function parseRuntimeClaimCandidate(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        return null;
+    }
+    const item = raw;
+    if (typeof item.undispatched_id !== "string" ||
+        typeof item.source_message_id !== "string" ||
+        typeof item.sender_address !== "string" ||
+        typeof item.content_preview !== "string" ||
+        typeof item.reason !== "string" ||
+        typeof item.claim_policy !== "string" ||
+        typeof item.arrived_at !== "number") {
+        return null;
+    }
+    const conversationRef = parseRuntimeConversationRef(item.conversation_ref);
+    return {
+        undispatched_id: item.undispatched_id,
+        source_message_id: item.source_message_id,
+        sender_address: item.sender_address,
+        content_preview: item.content_preview,
+        reason: item.reason,
+        claim_policy: item.claim_policy,
+        ...(typeof item.target_endpoint_id_hint === "string" && {
+            target_endpoint_id_hint: item.target_endpoint_id_hint,
+        }),
+        ...(typeof item.in_reply_to === "string" && {
+            in_reply_to: item.in_reply_to,
+        }),
+        ...(typeof item.origin_scid === "string" && {
+            origin_scid: item.origin_scid,
+        }),
+        ...(typeof item.origin_ncid === "string" && {
+            origin_ncid: item.origin_ncid,
+        }),
+        ...(conversationRef !== null && {
+            conversation_ref: conversationRef,
+        }),
+        ...(typeof item.active_assignment_id === "string" && {
+            active_assignment_id: item.active_assignment_id,
+        }),
+        ...(typeof item.active_target_endpoint_id === "string" && {
+            active_target_endpoint_id: item.active_target_endpoint_id,
+        }),
+        arrived_at: item.arrived_at,
+    };
+}
+function parseRuntimeConversationRef(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        return null;
+    }
+    const ref = raw;
+    if (ref.kind === "session_conversation" &&
+        typeof ref.id === "string" &&
+        ref.id.length > 0) {
+        return { kind: "session_conversation", id: ref.id };
+    }
+    return null;
+}
+function parseRuntimeConversationHistoryMessage(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        return null;
+    }
+    const item = raw;
+    if (typeof item.message_id !== "string" ||
+        typeof item.source_node_id !== "string" ||
+        typeof item.target_node_id !== "string" ||
+        typeof item.timestamp !== "string") {
+        return null;
+    }
+    return {
+        message_id: item.message_id,
+        source_node_id: item.source_node_id,
+        target_node_id: item.target_node_id,
+        timestamp: item.timestamp,
+        ...(typeof item.content === "string" && { content: item.content }),
+        ...(typeof item.content_type === "string" && {
+            content_type: item.content_type,
+        }),
+    };
+}
+function readRuntimeDispatchUndispatchedResponse(raw) {
+    if (!isRecord(raw)) {
+        return invalidWireResponse("invalid_runtime_dispatch_response", "invalid runtime dispatch response");
+    }
+    if (typeof raw.idempotency_key !== "string" ||
+        typeof raw.emitted_at !== "string" ||
+        typeof raw.accepted !== "boolean" ||
+        (raw.delivery_mode !== undefined && typeof raw.delivery_mode !== "string")) {
+        return invalidWireResponse("invalid_runtime_dispatch_response", "invalid runtime dispatch response");
+    }
+    return {
+        idempotency_key: raw.idempotency_key,
+        emitted_at: raw.emitted_at,
+        accepted: raw.accepted,
+        ...(typeof raw.delivery_mode === "string" && {
+            delivery_mode: raw.delivery_mode,
+        }),
+    };
+}
+function readRuntimeSelfSettleResponse(raw, params) {
+    if (!isRecord(raw)) {
+        return { ok: false, detail: "invalid runtime self-settle response" };
+    }
+    if (raw.settled !== true ||
+        !isNonEmptyString(raw.undispatched_id) ||
+        raw.undispatched_id !== params.undispatched_id ||
+        raw.remove_reason !== "handled_no_reply") {
+        return { ok: false, detail: "invalid runtime self-settle response" };
+    }
+    return {
+        ok: true,
+        settle: {
+            settled: true,
+            undispatched_id: raw.undispatched_id,
+            remove_reason: "handled_no_reply",
+        },
+    };
+}
+function readRuntimeUndispatchedDismissResponse(raw, params) {
+    const expectedReason = params.reason ?? "owner_dismissed";
+    if (!isRecord(raw)) {
+        return invalidWireResponse("invalid_runtime_undispatched_dismiss_response", "invalid runtime undispatched-dismiss response");
+    }
+    if (raw.dismissed !== true ||
+        !isNonEmptyString(raw.undispatched_id) ||
+        raw.undispatched_id !== params.undispatched_id ||
+        raw.remove_reason !== expectedReason ||
+        (raw.ttl_ms !== undefined &&
+            (typeof raw.ttl_ms !== "number" ||
+                !Number.isFinite(raw.ttl_ms) ||
+                raw.ttl_ms < 0))) {
+        return invalidWireResponse("invalid_runtime_undispatched_dismiss_response", "invalid runtime undispatched-dismiss response");
+    }
+    return {
+        dismissed: true,
+        undispatched_id: raw.undispatched_id,
+        remove_reason: expectedReason,
+        ...(typeof raw.ttl_ms === "number" && { ttl_ms: raw.ttl_ms }),
+    };
+}
+function readRuntimeAssignmentReplyIntentResponse(raw) {
+    if (!isRecord(raw) || raw.ok !== true) {
+        return invalidWireResponse("invalid_runtime_assignment_reply_intent_response", "invalid runtime assignment reply intent response");
+    }
+    if (raw.status === "committed" &&
+        hasExactKeys(raw, [
+            "ok",
+            "status",
+            "assignment_id",
+            "source_message_id",
+            "reply_request_id",
+            "outbound_message_id",
+        ]) &&
+        isNonEmptyString(raw.assignment_id) &&
+        isNonEmptyString(raw.source_message_id) &&
+        isNonEmptyString(raw.reply_request_id) &&
+        isNonEmptyString(raw.outbound_message_id)) {
+        return {
+            ok: true,
+            status: "committed",
+            assignment_id: raw.assignment_id,
+            source_message_id: raw.source_message_id,
+            reply_request_id: raw.reply_request_id,
+            outbound_message_id: raw.outbound_message_id,
+        };
+    }
+    if (raw.status === "already_emitted" &&
+        isNonEmptyString(raw.assignment_id) &&
+        isNonEmptyString(raw.source_message_id) &&
+        isNonEmptyString(raw.reply_request_id) &&
+        isNonEmptyString(raw.outbound_message_id) &&
+        (raw.ack_status === undefined ||
+            raw.ack_status === "delivered" ||
+            raw.ack_status === "stored")) {
+        return {
+            ok: true,
+            status: "already_emitted",
+            assignment_id: raw.assignment_id,
+            source_message_id: raw.source_message_id,
+            reply_request_id: raw.reply_request_id,
+            outbound_message_id: raw.outbound_message_id,
+            ...(raw.ack_status !== undefined && { ack_status: raw.ack_status }),
+        };
+    }
+    if (raw.status !== "pending" ||
+        !isNonEmptyString(raw.assignment_id) ||
+        !isNonEmptyString(raw.source_message_id) ||
+        !isNonEmptyString(raw.reply_request_id) ||
+        !isNonEmptyString(raw.outbound_message_id) ||
+        !isNonEmptyString(raw.gateway_receipt_token)) {
+        return invalidWireResponse("invalid_runtime_assignment_reply_intent_response", "invalid runtime assignment reply intent response");
+    }
+    const gatewayMessage = readRuntimeAssignmentReplyGatewayMessage(raw.gateway_message);
+    if (gatewayMessage === null) {
+        return invalidWireResponse("invalid_runtime_assignment_reply_gateway_message", "invalid runtime assignment reply gateway message");
+    }
+    if (gatewayMessage.messageId !== raw.outbound_message_id ||
+        gatewayMessage.assignmentReplyReceiptToken !== raw.gateway_receipt_token) {
+        return invalidWireResponse("runtime_assignment_reply_intent_mismatch", "runtime assignment reply intent fields do not match");
+    }
+    return {
+        ok: true,
+        status: "pending",
+        assignment_id: raw.assignment_id,
+        source_message_id: raw.source_message_id,
+        reply_request_id: raw.reply_request_id,
+        outbound_message_id: raw.outbound_message_id,
+        gateway_receipt_token: raw.gateway_receipt_token,
+        gateway_message: gatewayMessage,
+    };
+}
+function readRuntimeAssignmentReplyGatewayMessage(raw) {
+    if (!isRecord(raw))
+        return null;
+    const metadata = isRecord(raw.metadata) ? raw.metadata : null;
+    if (raw.event !== "SEND_MESSAGE" ||
+        !isNonEmptyString(raw.messageId) ||
+        !isNonEmptyString(raw.to) ||
+        !isNonEmptyString(raw.content) ||
+        !isNonEmptyString(raw.contentType) ||
+        metadata === null ||
+        !isNonEmptyString(raw.assignmentReplyReceiptToken)) {
+        return null;
+    }
+    if (findPeerVisibleRuntimeMetadataKeys(metadata).length > 0)
+        return null;
+    if (findGatewayLocalReceiptMetadataKeys(metadata).length > 0)
+        return null;
+    return {
+        event: "SEND_MESSAGE",
+        messageId: raw.messageId,
+        to: raw.to,
+        content: raw.content,
+        contentType: raw.contentType,
+        metadata,
+        assignmentReplyReceiptToken: raw.assignmentReplyReceiptToken,
+    };
+}
+function readRuntimeOutboundMessageIntentResponse(raw) {
+    if (!isRecord(raw) || raw.ok !== true) {
+        return invalidWireResponse("invalid_runtime_outbound_message_intent_response", "invalid runtime outbound message intent response");
+    }
+    if (raw.status === "already_emitted" &&
+        isNonEmptyString(raw.send_request_id) &&
+        isNonEmptyString(raw.outbound_message_id) &&
+        isNonEmptyString(raw.correlation_id) &&
+        (raw.ack_status === undefined ||
+            raw.ack_status === "delivered" ||
+            raw.ack_status === "stored")) {
+        return {
+            ok: true,
+            status: "already_emitted",
+            send_request_id: raw.send_request_id,
+            outbound_message_id: raw.outbound_message_id,
+            correlation_id: raw.correlation_id,
+            ...(raw.ack_status !== undefined && { ack_status: raw.ack_status }),
+        };
+    }
+    if (raw.status !== "pending" ||
+        !isNonEmptyString(raw.send_request_id) ||
+        !isNonEmptyString(raw.outbound_message_id) ||
+        !isNonEmptyString(raw.correlation_id) ||
+        !isNonEmptyString(raw.gateway_receipt_token)) {
+        return invalidWireResponse("invalid_runtime_outbound_message_intent_response", "invalid runtime outbound message intent response");
+    }
+    const gatewayMessage = readRuntimeOutboundGatewayMessage(raw.gateway_message);
+    if (gatewayMessage === null) {
+        return invalidWireResponse("invalid_runtime_outbound_gateway_message", "invalid runtime outbound gateway message");
+    }
+    if (gatewayMessage.messageId !== raw.outbound_message_id ||
+        gatewayMessage.runtimeOutboundReceiptToken !== raw.gateway_receipt_token ||
+        gatewayMessage.metadata.correlation_id !== raw.correlation_id) {
+        return invalidWireResponse("runtime_outbound_message_intent_mismatch", "runtime outbound message intent fields do not match");
+    }
+    return {
+        ok: true,
+        status: "pending",
+        send_request_id: raw.send_request_id,
+        outbound_message_id: raw.outbound_message_id,
+        correlation_id: raw.correlation_id,
+        gateway_receipt_token: raw.gateway_receipt_token,
+        gateway_message: gatewayMessage,
+    };
+}
+function readRuntimeOutboundGatewayMessage(raw) {
+    if (!isRecord(raw))
+        return null;
+    const metadata = isRecord(raw.metadata) ? raw.metadata : null;
+    if (raw.event !== "SEND_MESSAGE" ||
+        !isNonEmptyString(raw.messageId) ||
+        !isNonEmptyString(raw.to) ||
+        !isNonEmptyString(raw.content) ||
+        !isNonEmptyString(raw.contentType) ||
+        metadata === null ||
+        !isNonEmptyString(raw.runtimeOutboundReceiptToken)) {
+        return null;
+    }
+    if (findPeerVisibleRuntimeMetadataKeys(metadata).length > 0)
+        return null;
+    if (findGatewayLocalReceiptMetadataKeys(metadata).length > 0)
+        return null;
+    return {
+        event: "SEND_MESSAGE",
+        messageId: raw.messageId,
+        to: raw.to,
+        content: raw.content,
+        contentType: raw.contentType,
+        metadata,
+        runtimeOutboundReceiptToken: raw.runtimeOutboundReceiptToken,
+    };
+}
+function findGatewayLocalReceiptMetadataKeys(value) {
+    const keys = new Set();
+    visitGatewayLocalReceiptMetadata(value, keys);
+    return [...keys].sort();
+}
+function visitGatewayLocalReceiptMetadata(value, keys) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            visitGatewayLocalReceiptMetadata(item, keys);
+        return;
+    }
+    if (!value || typeof value !== "object")
+        return;
+    for (const [key, child] of Object.entries(value)) {
+        if (key === "assignmentReplyReceiptToken" ||
+            key === "assignment_reply_receipt_token" ||
+            key === "runtimeOutboundReceiptToken" ||
+            key === "runtime_outbound_receipt_token" ||
+            key === "gatewayReceiptToken" ||
+            key === "gateway_receipt_token") {
+            keys.add(key);
+        }
+        visitGatewayLocalReceiptMetadata(child, keys);
+    }
+}
+function readRuntimeOwnerActionHandoffInitResponse(raw) {
+    if (!isRecord(raw)) {
+        return invalidWireResponse("invalid_runtime_owner_action_handoff_init_response", "invalid runtime owner-action handoff init response");
+    }
+    if (typeof raw.handoff_session_id !== "string" ||
+        typeof raw.approve_url !== "string" ||
+        typeof raw.expires_at !== "string") {
+        return invalidWireResponse("invalid_runtime_owner_action_handoff_init_response", "invalid runtime owner-action handoff init response");
+    }
+    return {
+        handoff_session_id: raw.handoff_session_id,
+        approve_url: raw.approve_url,
+        expires_at: raw.expires_at,
+    };
+}
+function readRuntimeOwnerActionHandoffPollResponse(raw) {
+    if (!isRecord(raw) || typeof raw.status !== "string") {
+        return invalidWireResponse("invalid_runtime_owner_action_handoff_poll_response", "invalid runtime owner-action handoff poll response");
+    }
+    if (raw.status === "pending")
+        return { status: "pending" };
+    if (raw.status === "completed") {
+        if (raw.dispatch === undefined) {
+            return invalidWireResponse("invalid_runtime_owner_action_handoff_poll_response", "invalid runtime owner-action handoff poll response");
+        }
+        let dispatch;
+        try {
+            dispatch = readRuntimeDispatchUndispatchedResponse(raw.dispatch);
+        }
+        catch (err) {
+            if (err instanceof RuntimeAdapterApiError) {
+                return invalidWireResponse("invalid_runtime_owner_action_handoff_poll_response", "invalid runtime owner-action handoff poll response");
+            }
+            throw err;
+        }
+        return {
+            status: "completed",
+            dispatch,
+        };
+    }
+    if (raw.status === "failed") {
+        if (typeof raw.error !== "string") {
+            return invalidWireResponse("invalid_runtime_owner_action_handoff_poll_response", "invalid runtime owner-action handoff poll response");
+        }
+        return {
+            status: "failed",
+            error: raw.error,
+            ...(typeof raw.message === "string" && { message: raw.message }),
+            ...(typeof raw.retryable === "boolean" && {
+                retryable: raw.retryable,
+            }),
+            ...(typeof raw.dispatch_status_code === "number" && {
+                dispatch_status_code: raw.dispatch_status_code,
+            }),
+        };
+    }
+    return invalidWireResponse("invalid_runtime_owner_action_handoff_poll_response", "invalid runtime owner-action handoff poll response");
+}
+async function readRuntimeSelfClaimSuccess(res, params) {
+    const rawBody = (await res.json().catch(() => null));
+    const body = rawBody !== null && typeof rawBody === "object" && !Array.isArray(rawBody)
+        ? rawBody
+        : null;
+    const targetRef = parseRuntimeWorkTargetRef(body?.target_ref);
+    const assignmentId = body?.assignment_id;
+    const undispatchedId = body?.undispatched_id;
+    const sourceMessageId = body?.source_message_id;
+    const brokerProjectionToken = body?.broker_projection_token;
+    const assignedAt = body?.assigned_at;
+    const claimed = body?.claimed;
+    const recovered = body?.recovered;
+    const message = body?.message;
+    if (targetRef !== null &&
+        targetMatchesClaimParams(targetRef, params) &&
+        typeof assignmentId === "string" &&
+        typeof undispatchedId === "string" &&
+        typeof sourceMessageId === "string" &&
+        typeof brokerProjectionToken === "string" &&
+        typeof assignedAt === "number" &&
+        typeof claimed === "boolean" &&
+        (recovered === undefined || typeof recovered === "boolean") &&
+        typeof message === "object" &&
+        message !== null &&
+        typeof message.from === "string" &&
+        typeof message.content === "string" &&
+        typeof message.contentType === "string" &&
+        typeof message.sourceMessageId === "string" &&
+        message.sourceMessageId === sourceMessageId &&
+        undispatchedId === params.undispatched_id &&
+        (message.metadata === undefined ||
+            (typeof message.metadata === "object" &&
+                message.metadata !== null &&
+                !Array.isArray(message.metadata)))) {
+        const claim = {
+            assignment_id: assignmentId,
+            undispatched_id: undispatchedId,
+            source_message_id: sourceMessageId,
+            target_ref: targetRef,
+            broker_projection_token: brokerProjectionToken,
+            assigned_at: assignedAt,
+            claimed,
+            ...(recovered !== undefined && { recovered }),
+            message: {
+                from: message.from,
+                content: message.content,
+                contentType: message.contentType,
+                ...(message.metadata !== undefined && {
+                    metadata: message.metadata,
+                }),
+                sourceMessageId: message.sourceMessageId,
+            },
+        };
+        return { ok: true, claim };
+    }
+    const postCasInvalidClaim = body
+        ? {
+            ...body,
+            ...(targetRef !== null && { target_ref: targetRef }),
+        }
+        : undefined;
+    return {
+        ok: false,
+        terminal: true,
+        status: res.status,
+        detail: targetRef !== null && !targetMatchesClaimParams(targetRef, params)
+            ? "self-claim target mismatch"
+            : "invalid self-claim response",
+        ...(postCasInvalidClaim !== undefined && { postCasInvalidClaim }),
+    };
+}
+function targetMatchesClaimParams(targetRef, params) {
+    if (targetRef === null)
+        return false;
+    if (targetRef.projection_endpoint_id !== params.target_endpoint_id) {
+        return false;
+    }
+    if (params.expected_target_ref === undefined)
+        return true;
+    return sameRuntimeWorkTargetRef(targetRef, params.expected_target_ref);
+}
+function buildPostCasReleaseParams(claim, endpointNonce) {
+    if (!claim ||
+        typeof claim.undispatched_id !== "string" ||
+        typeof claim.source_message_id !== "string" ||
+        typeof claim.assignment_id !== "string" ||
+        typeof claim.broker_projection_token !== "string" ||
+        claim.target_ref === undefined) {
+        return undefined;
+    }
+    return {
+        undispatched_id: claim.undispatched_id,
+        source_message_id: claim.source_message_id,
+        assignment_id: claim.assignment_id,
+        target_ref: claim.target_ref,
+        endpoint_nonce: endpointNonce,
+        broker_projection_token: claim.broker_projection_token,
+    };
+}
+async function readErrorEnvelope(res) {
+    try {
+        const body = (await res.json().catch(() => null));
+        if (!body)
+            return {};
+        return {
+            ...(typeof body.error === "string" && { code: body.error }),
+            ...(typeof body.message === "string" && { message: body.message }),
+            ...(isRuntimeAssignmentFailureCategory(body.assignment_failure_category) && {
+                assignmentFailureCategory: body.assignment_failure_category,
+            }),
+        };
+    }
+    catch {
+        return {};
+    }
+}
+async function readErrorDetail(res) {
+    const error = await readErrorEnvelope(res);
+    return [error.code, error.message].filter(Boolean).join(": ") || undefined;
+}
+async function terminalHttpOutcome(res) {
+    const error = await readErrorEnvelope(res);
+    return {
+        ok: false,
+        terminal: true,
+        status: res.status,
+        ...errorOutcomeFields(error),
+    };
+}
+async function transientHttpOutcome(res) {
+    const error = await readErrorEnvelope(res);
+    return {
+        ok: false,
+        terminal: false,
+        status: res.status,
+        ...errorOutcomeFields(error),
+    };
+}
+function transientNetworkOutcome(err) {
+    return {
+        ok: false,
+        terminal: false,
+        detail: networkDetail(err),
+    };
+}
+function networkDetail(err) {
+    if (err instanceof RuntimeAdapterNetworkError) {
+        return `${err.requestKind}: ${err.code}: ${err.detail}`;
+    }
+    return err instanceof Error ? err.message : String(err);
+}
+function errorOutcomeFields(error) {
+    const detail = [error.code, error.message].filter(Boolean).join(": ");
+    return {
+        ...(detail.length > 0 && { detail }),
+        ...(error.assignmentFailureCategory !== undefined && {
+            assignmentFailureCategory: error.assignmentFailureCategory,
+        }),
+    };
+}
+function isRuntimeAssignmentFailureCategory(value) {
+    return RUNTIME_ASSIGNMENT_FAILURE_CATEGORIES.includes(value);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, keys) {
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    return (actual.length === expected.length &&
+        actual.every((key, index) => key === expected[index]));
+}
+function readOptionalStringArray(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        return null;
+    }
+    return value;
+}
+function parseRuntimeSessionNaming(value) {
+    if (!isRecord(value) || !isNonEmptyString(value.nickname))
+        return null;
+    if (value.owner_edited_name !== undefined &&
+        value.owner_edited_name !== null &&
+        typeof value.owner_edited_name !== "string") {
+        return null;
+    }
+    return {
+        nickname: value.nickname,
+        ...(value.owner_edited_name !== undefined && {
+            owner_edited_name: value.owner_edited_name,
+        }),
+    };
+}
+function isWorkspaceMetadata(value) {
+    return (isRecord(value) &&
+        typeof value.root === "string" &&
+        typeof value.cwd === "string" &&
+        (value.remote === undefined || typeof value.remote === "string") &&
+        (value.branch === undefined || typeof value.branch === "string"));
+}
+function isEndpointFingerprint(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.workspace_hash_per_peer === undefined)
+        return true;
+    if (!isRecord(value.workspace_hash_per_peer))
+        return false;
+    return Object.values(value.workspace_hash_per_peer).every((item) => typeof item === "string");
+}
+function invalidWireResponse(code, message) {
+    throw new RuntimeAdapterApiError(502, code, message);
+}