@seams/wallet-server 0.6.2 → 0.7.3

package/dist/esm/router/domains/ed25519Yao/registration/routerAbEd25519YaoRegistrationRequestScopedCloudflare.js

@@ -1,9 +1,10 @@
 import { parseRouterAbEd25519YaoRegistrationActivationExecuteRequestV1, parseRouterAbEd25519YaoRegistrationAdmissionRequestV1 } from "../../../../shared-ts/src/utils/routerAbEd25519Yao.js";
 import { ROUTER_AB_TRACE_ID_HEADER_V1, createRouterAbTraceContextV1, parseRouterAbTraceContextV1 } from "../../../../shared-ts/src/utils/routerAbTraceContext.js";
 import { json, readJson } from "../../../framework/http.js";
-import { InMemoryRouterAbEd25519YaoRegistrationService, InMemoryRouterAbEd25519YaoRegistrationStateV1 } from "./routerAbEd25519YaoRegistration.js";
+import { InMemoryRouterAbEd25519YaoRegistrationService, routerAbEd25519YaoExecutionMatchesAdmissionV1 } from "./routerAbEd25519YaoRegistration.js";
 import { InMemoryRouterAbEd25519YaoRegistrationIntentAuthorizationAdapter, routerAbEd25519YaoBearerCredentialDigestV1 } from "./routerAbEd25519YaoRegistrationIntentAuthorization.js";
-import { routerAbEd25519YaoRegistrationExecutionRequestDigestV1 } from "./routerAbEd25519YaoRegistrationExecutionRecord.js";
+import { pinRouterAbEd25519YaoRegistrationDispatchRootV1, routerAbEd25519YaoRegistrationResultFromRouterAnswerV1 } from "./routerAbEd25519YaoRegistrationExecutionRecord.js";
+import { routerAbEd25519YaoAdmittedRegistrationAuthorityV1 } from "../capabilityLifecycle/routerAbEd25519YaoProductRegistrationPartitionedStateStore.js";
 import { runRouterAbEd25519YaoRegistrationTwoPhaseV1 } from "./routerAbEd25519YaoRegistrationTwoPhaseRunner.js";
 //#region src/router/domains/ed25519Yao/registration/routerAbEd25519YaoRegistrationRequestScopedCloudflare.ts
 async function handleRouterAbEd25519YaoRegistrationRequestScopedCloudflareV1(input) {
@@ -66,7 +67,8 @@ async function refreshContinuationAuthority(input, lifecycleId) {
 		if ((await input.store.commit({
 			lifecycleId,
 			state: loaded.state,
-			baseline: loaded.baseline
+			baseline: loaded.baseline,
+			companionWrite: null
 		})).kind === "stored") return null;
 	}
 	return {
@@ -78,6 +80,7 @@ async function refreshContinuationAuthority(input, lifecycleId) {
 }
 async function runAdmissionRequest(input, request, trace) {
 	const lifecycleId = request.scope.lifecycle_id;
+	let dispatchRoot = null;
 	return mapAdmissionRunResult(await runRouterAbEd25519YaoRegistrationTwoPhaseV1({
 		lifecycleId,
 		store: input.store,
@@ -104,11 +107,25 @@ async function runAdmissionRequest(input, request, trace) {
 					kind: "rejected",
 					value: preparation.failure
 				};
-				case "claimed": return {
-					kind: "claimed",
-					state,
-					claim: preparation.claim
-				};
+				case "claimed":
+					try {
+						dispatchRoot = await input.backend.resolveRegistrationDispatchRoot(request);
+					} catch (error) {
+						return {
+							kind: "rejected",
+							value: {
+								ok: false,
+								status: 503,
+								code: "admission_failed",
+								message: `registration tenant root is unavailable: ${error instanceof Error ? error.message : String(error)}`
+							}
+						};
+					}
+					return {
+						kind: "claimed",
+						state,
+						claim: preparation.claim
+					};
 			}
 		},
 		backend: async () => {
@@ -125,68 +142,60 @@ async function runAdmissionRequest(input, request, trace) {
 			}
 		},
 		complete: async (state, claim, backend) => {
+			const admitted = new InMemoryRouterAbEd25519YaoRegistrationService(input.backend, state.registration).commitAdmit({
+				request,
+				claim,
+				outcome: {
+					kind: "backend_response",
+					result: backend
+				}
+			});
+			if (admitted.ok) {
+				if (dispatchRoot === null) throw new Error("registration admission resolved no tenant root to pin");
+				pinRouterAbEd25519YaoRegistrationDispatchRootV1(state.registration, lifecycleId, dispatchRoot);
+			}
 			return {
+				kind: "state",
 				state,
-				value: new InMemoryRouterAbEd25519YaoRegistrationService(input.backend, state.registration).commitAdmit({
-					request,
-					claim,
-					outcome: {
-						kind: "backend_response",
-						result: backend
-					}
-				})
+				value: admitted
 			};
 		}
 	}));
 }
+/**
+* Checks the execute against this Gateway's admission, then asks the Router
+* to run it once, on the tenant root pinned at admission. The Router owns the
+* execution: it claims it in its wallet object, records the terminal answer
+* before replying, answers an exact retry from that record, and replays a run
+* cut short once its claim lapses. An execute never looks the active root up
+* again, so a completed execution's answer outlives the root's lineage.
+*/
 async function runExecutionRequest(input, request, trace) {
 	const lifecycleId = request.binding.lifecycle.lifecycle_id;
 	const credentialStartedAt = performance.now();
 	const credential = await routerAbEd25519YaoBearerCredentialDigestV1(input.request);
-	const credentialDigestMs = elapsedMs(credentialStartedAt);
-	if (!credential.ok) return timedExecutionResult(credential.result, {
-		credentialDigestMs,
-		requestDigestMs: 0,
-		d1ClaimMs: 0,
+	const timing = {
+		credentialDigestMs: elapsedMs(credentialStartedAt),
+		d1AdmissionReadMs: 0,
 		routerExecutionMs: 0,
 		routerServerTiming: null,
-		resultReconstructionMs: 0,
-		d1TerminalCommitMs: 0
-	});
-	const requestDigestStartedAt = performance.now();
-	const requestDigestSha256Hex = await routerAbEd25519YaoRegistrationExecutionRequestDigestV1(request);
-	const requestDigestMs = elapsedMs(requestDigestStartedAt);
-	const d1ClaimStartedAt = performance.now();
-	const claim = await input.store.claimRegistrationExecution({
-		lifecycleId,
-		request,
-		requestDigestSha256Hex,
-		credentialDigestSha256Hex: credential.digestSha256Hex,
-		nowMs: Date.now()
-	});
+		resultReconstructionMs: 0
+	};
+	if (!credential.ok) return timedExecutionResult(credential.result, timing);
+	const admissionStartedAt = performance.now();
+	const authority = routerAbEd25519YaoAdmittedRegistrationAuthorityV1((await input.store.load(lifecycleId)).state, lifecycleId);
 	const timingBeforeRouter = {
-		credentialDigestMs,
-		requestDigestMs,
-		d1ClaimMs: elapsedMs(d1ClaimStartedAt),
-		routerExecutionMs: 0,
-		routerServerTiming: null,
-		resultReconstructionMs: 0,
-		d1TerminalCommitMs: 0
+		...timing,
+		d1AdmissionReadMs: elapsedMs(admissionStartedAt)
 	};
-	switch (claim.kind) {
-		case "completed": return timedExecutionResult({
-			ok: true,
-			status: 200,
-			value: claim.value
-		}, timingBeforeRouter);
-		case "failed": return timedExecutionResult(claim.value, timingBeforeRouter);
-		case "rejected": return timedExecutionResult(executionClaimFailure(claim), timingBeforeRouter);
-		case "claimed": break;
-	}
+	if (!authority) return timedExecutionResult(executionRefusal("unknown_registration", "registration admission was not found"), timingBeforeRouter);
+	if (!routerAbEd25519YaoExecutionMatchesAdmissionV1(request, authority.admissionReceipt)) return timedExecutionResult(executionRefusal("binding_mismatch", "registration execution does not match the admitted binding"), timingBeforeRouter);
+	if (authority.credentialDigestSha256Hex !== credential.digestSha256Hex) return timedExecutionResult(executionRefusal("credential_rejected", "registration execution credential does not match its admission subject"), timingBeforeRouter);
+	if (authority.expiresAtMs <= Date.now()) return timedExecutionResult(executionRefusal("credential_expired", "registration intent credential is expired"), timingBeforeRouter);
 	let backend;
 	const routerExecutionStartedAt = performance.now();
 	try {
-		backend = await input.backend.execute(request, claim.value.admissionRequest, trace);
+		backend = await input.backend.executePinnedRegistration(request, authority.admissionRequest, authority.dispatchRoot, trace);
 	} catch (error) {
 		return timedExecutionResult({
 			ok: false,
@@ -198,52 +207,29 @@ async function runExecutionRequest(input, request, trace) {
 			routerExecutionMs: elapsedMs(routerExecutionStartedAt)
 		});
 	}
-	const routerExecutionMs = elapsedMs(routerExecutionStartedAt);
-	const routerServerTiming = input.backend.takeLastRouterServerTiming?.() ?? null;
+	const routerTiming = {
+		...timingBeforeRouter,
+		routerExecutionMs: elapsedMs(routerExecutionStartedAt),
+		routerServerTiming: input.backend.takeLastRouterServerTiming?.() ?? null
+	};
+	if (!backend.ok && backend.code === "execution_in_progress") return timedExecutionResult(executionRefusal("execution_in_progress", backend.message), routerTiming);
+	if (!backend.ok && backend.code === "execution_mismatch") return timedExecutionResult(executionRefusal("binding_mismatch", backend.message), routerTiming);
 	if (isRetryableRegistrationBackendFailure(backend)) return timedExecutionResult({
 		ok: false,
 		status: 503,
 		code: "execution_failed",
 		message: backend.message
-	}, {
-		...timingBeforeRouter,
-		routerExecutionMs,
-		routerServerTiming
-	});
+	}, routerTiming);
 	const reconstructionStartedAt = performance.now();
-	const terminal = completeClaimedExecution(input.backend, claim.value, request, backend);
-	const resultReconstructionMs = elapsedMs(reconstructionStartedAt);
-	const terminalCommitStartedAt = performance.now();
-	const committed = await input.store.commitRegistrationExecution({
-		claimed: claim.value,
-		claimedVersion: claim.version,
-		outcome: terminal.ok ? {
-			kind: "completed",
-			result: terminal.value
-		} : {
-			kind: "failed",
-			failure: terminal
-		}
+	return timedExecutionResult(routerAbEd25519YaoRegistrationResultFromRouterAnswerV1({
+		backend: input.backend,
+		authority,
+		request,
+		answer: backend
+	}), {
+		...routerTiming,
+		resultReconstructionMs: elapsedMs(reconstructionStartedAt)
 	});
-	const d1TerminalCommitMs = elapsedMs(terminalCommitStartedAt);
-	const timing = {
-		...timingBeforeRouter,
-		routerExecutionMs,
-		routerServerTiming,
-		resultReconstructionMs,
-		d1TerminalCommitMs
-	};
-	if (committed.kind === "uncertain") return timedExecutionResult({
-		ok: false,
-		status: 503,
-		code: "execution_failed",
-		message: "registration execution terminal persistence is uncertain"
-	}, timing);
-	return timedExecutionResult(isRegistrationFailure(committed.value) ? committed.value : {
-		ok: true,
-		status: 200,
-		value: committed.value
-	}, timing);
 }
 function elapsedMs(startedAt) {
 	return Math.max(0, performance.now() - startedAt);
@@ -254,69 +240,40 @@ function timedExecutionResult(result, timing) {
 		timing
 	};
 }
-function completeClaimedExecution(backendAdapter, claimed, request, backend) {
-	const state = new InMemoryRouterAbEd25519YaoRegistrationStateV1();
-	const sessionKey = bytesToHex(claimed.admissionReceipt.binding.session_id);
-	state.states.set(sessionKey, {
-		kind: "admitted",
-		admissionRequest: claimed.admissionRequest,
-		admissionReceipt: claimed.admissionReceipt
-	});
-	state.lifecycleSessions.set(claimed.lifecycleId, sessionKey);
-	const service = new InMemoryRouterAbEd25519YaoRegistrationService(backendAdapter, state);
-	const prepared = service.prepareExecute(request);
-	if (prepared.kind !== "claimed") throw new Error("claimed Yao registration execution could not be reconstructed");
-	return service.commitExecute({
-		request,
-		claim: prepared.claim,
-		outcome: {
-			kind: "backend_response",
-			result: backend
-		}
-	});
-}
-function executionClaimFailure(claim) {
-	switch (claim.code) {
+function executionRefusal(code, message) {
+	switch (code) {
 		case "unknown_registration": return {
 			ok: false,
 			status: 404,
 			code: "unknown_registration",
-			message: claim.message
+			message
 		};
 		case "binding_mismatch": return {
 			ok: false,
 			status: 409,
 			code: "binding_mismatch",
-			message: claim.message
+			message
 		};
 		case "credential_rejected": return {
 			ok: false,
 			status: 403,
 			code: "registration_intent_subject_mismatch",
-			message: claim.message
+			message
 		};
 		case "credential_expired": return {
 			ok: false,
 			status: 403,
 			code: "registration_intent_credential_expired",
-			message: claim.message
+			message
 		};
 		case "execution_in_progress": return {
 			ok: false,
 			status: 409,
 			code: "execution_in_progress",
-			message: claim.message
+			message
 		};
 	}
 }
-function bytesToHex(bytes) {
-	let encoded = "";
-	for (const byte of bytes) encoded += byte.toString(16).padStart(2, "0");
-	return encoded;
-}
-function isRegistrationFailure(value) {
-	return "ok" in value && value.ok === false;
-}
 function isRetryableRegistrationBackendFailure(result) {
 	return !result.ok && (result.code === "worker_unavailable" || result.code === "worker_rejected" || result.code === "router_execution_retryable");
 }
@@ -401,11 +358,9 @@ function registrationResultResponse(result, timing) {
 function registrationExecutionServerTiming(timing) {
 	const gatewayTiming = [
 		serverTimingMetric("yao_credential_digest", timing.credentialDigestMs),
-		serverTimingMetric("yao_request_digest", timing.requestDigestMs),
-		serverTimingMetric("yao_d1_claim", timing.d1ClaimMs),
+		serverTimingMetric("yao_d1_admission_read", timing.d1AdmissionReadMs),
 		serverTimingMetric("yao_router_execution", timing.routerExecutionMs),
-		serverTimingMetric("yao_result_reconstruction", timing.resultReconstructionMs),
-		serverTimingMetric("yao_d1_terminal_commit", timing.d1TerminalCommitMs)
+		serverTimingMetric("yao_result_reconstruction", timing.resultReconstructionMs)
 	];
 	if (timing.routerServerTiming) gatewayTiming.push(timing.routerServerTiming);
 	return gatewayTiming.join(", ");

package/dist/esm/router/domains/ed25519Yao/registration/routerAbEd25519YaoRegistrationSideEffectBoundary.js

@@ -1,3 +1,4 @@
+import { hasExactKeys } from "../../../../shared-ts/src/utils/exactKeys.js";
 //#region src/router/domains/ed25519Yao/registration/routerAbEd25519YaoRegistrationSideEffectBoundary.ts
 const SIDE_EFFECT_CLAIM_FIELDS = [
 	"kind",
@@ -34,79 +35,66 @@ function throwIfRouterAbEd25519YaoRetryableSideEffectFailureV1(failure) {
 function parseRouterAbEd25519YaoRegistrationSideEffectRecordV2(raw, input) {
 	const record = readRouterAbEd25519YaoRegistrationSideEffectRecordObjectV1(raw);
 	if (record === null || record.operation !== input.operation) return null;
-	if (record.kind === "router_ab_ed25519_yao_registration_side_effect_claim_v1") {
-		if (!hasExactRouterAbEd25519YaoRegistrationSideEffectRecordKeys(record, SIDE_EFFECT_CLAIM_FIELDS)) return null;
-		const requestFingerprint = parseFingerprint(record.requestFingerprint);
-		const preparedArtifactFingerprint = parsePreparedFingerprint(record.preparedArtifactFingerprint);
-		const claimedAtMs = parseTimestamp(record.claimedAtMs);
-		const prepared = input.parsePrepared(record.prepared);
-		if (requestFingerprint === null || preparedArtifactFingerprint === null || claimedAtMs === null || prepared === null) return null;
-		return {
-			kind: "router_ab_ed25519_yao_registration_side_effect_claim_v1",
-			operation: input.operation,
-			requestFingerprint,
-			preparedArtifactFingerprint,
-			claimedAtMs,
-			prepared
-		};
-	}
-	if (record.kind !== "router_ab_ed25519_yao_registration_side_effect_completion_v2" || !hasExactRouterAbEd25519YaoRegistrationSideEffectRecordKeys(record, SIDE_EFFECT_COMPLETION_V2_FIELDS)) return null;
-	const requestFingerprint = parseFingerprint(record.requestFingerprint);
-	const preparedArtifactFingerprint = parsePreparedFingerprint(record.preparedArtifactFingerprint);
-	const claimedAtMs = parseTimestamp(record.claimedAtMs);
-	const prepared = input.parsePrepared(record.prepared);
-	if (requestFingerprint === null || preparedArtifactFingerprint === null || claimedAtMs === null || prepared === null) return null;
+	if (record.kind === "router_ab_ed25519_yao_registration_side_effect_claim_v1") return parseRouterAbEd25519YaoRegistrationSideEffectClaimV1(record, input);
+	if (record.kind !== "router_ab_ed25519_yao_registration_side_effect_completion_v2" || !hasExactKeys(record, SIDE_EFFECT_COMPLETION_V2_FIELDS)) return null;
+	const claim = parseRouterAbEd25519YaoRegistrationSideEffectClaimFields(record, input.parsePrepared);
+	if (claim === null) return null;
 	const completedAtMs = parseTimestamp(record.completedAtMs);
 	const receipt = input.parseReceipt(record.receipt);
 	if (completedAtMs === null || receipt === null) return null;
 	return {
 		kind: "router_ab_ed25519_yao_registration_side_effect_completion_v2",
 		operation: input.operation,
-		requestFingerprint,
-		preparedArtifactFingerprint,
-		claimedAtMs,
+		requestFingerprint: claim.requestFingerprint,
+		preparedArtifactFingerprint: claim.preparedArtifactFingerprint,
+		claimedAtMs: claim.claimedAtMs,
 		completedAtMs,
-		prepared,
+		prepared: claim.prepared,
 		receipt
 	};
 }
 function parseRouterAbEd25519YaoRegistrationSideEffectRecordV1(raw, input) {
 	const record = readRouterAbEd25519YaoRegistrationSideEffectRecordObjectV1(raw);
 	if (record === null || record.operation !== input.operation) return null;
-	if (record.kind === "router_ab_ed25519_yao_registration_side_effect_claim_v1") {
-		if (!hasExactRouterAbEd25519YaoRegistrationSideEffectRecordKeys(record, SIDE_EFFECT_CLAIM_FIELDS)) return null;
-		const requestFingerprint = parseFingerprint(record.requestFingerprint);
-		const preparedArtifactFingerprint = parsePreparedFingerprint(record.preparedArtifactFingerprint);
-		const claimedAtMs = parseTimestamp(record.claimedAtMs);
-		const prepared = input.parsePrepared(record.prepared);
-		if (requestFingerprint === null || preparedArtifactFingerprint === null || claimedAtMs === null || prepared === null) return null;
-		return {
-			kind: "router_ab_ed25519_yao_registration_side_effect_claim_v1",
-			operation: input.operation,
-			requestFingerprint,
-			preparedArtifactFingerprint,
-			claimedAtMs,
-			prepared
-		};
-	}
-	if (record.kind !== "router_ab_ed25519_yao_registration_side_effect_completion_v1" || !hasExactRouterAbEd25519YaoRegistrationSideEffectRecordKeys(record, SIDE_EFFECT_COMPLETION_V1_FIELDS)) return null;
-	const requestFingerprint = parseFingerprint(record.requestFingerprint);
-	const preparedArtifactFingerprint = parsePreparedFingerprint(record.preparedArtifactFingerprint);
-	const claimedAtMs = parseTimestamp(record.claimedAtMs);
-	const prepared = input.parsePrepared(record.prepared);
-	if (requestFingerprint === null || preparedArtifactFingerprint === null || claimedAtMs === null || prepared === null) return null;
+	if (record.kind === "router_ab_ed25519_yao_registration_side_effect_claim_v1") return parseRouterAbEd25519YaoRegistrationSideEffectClaimV1(record, input);
+	if (record.kind !== "router_ab_ed25519_yao_registration_side_effect_completion_v1" || !hasExactKeys(record, SIDE_EFFECT_COMPLETION_V1_FIELDS)) return null;
+	const claim = parseRouterAbEd25519YaoRegistrationSideEffectClaimFields(record, input.parsePrepared);
+	if (claim === null) return null;
 	const completedAtMs = parseTimestamp(record.completedAtMs);
 	const response = input.parseResponse(record.response);
 	if (completedAtMs === null || response === null) return null;
 	return {
 		kind: "router_ab_ed25519_yao_registration_side_effect_completion_v1",
 		operation: input.operation,
+		requestFingerprint: claim.requestFingerprint,
+		preparedArtifactFingerprint: claim.preparedArtifactFingerprint,
+		claimedAtMs: claim.claimedAtMs,
+		completedAtMs,
+		prepared: claim.prepared,
+		response
+	};
+}
+function parseRouterAbEd25519YaoRegistrationSideEffectClaimV1(record, input) {
+	if (!hasExactKeys(record, SIDE_EFFECT_CLAIM_FIELDS)) return null;
+	const claim = parseRouterAbEd25519YaoRegistrationSideEffectClaimFields(record, input.parsePrepared);
+	if (claim === null) return null;
+	return {
+		kind: "router_ab_ed25519_yao_registration_side_effect_claim_v1",
+		operation: input.operation,
+		...claim
+	};
+}
+function parseRouterAbEd25519YaoRegistrationSideEffectClaimFields(record, parsePrepared) {
+	const requestFingerprint = parseFingerprint(record.requestFingerprint);
+	const preparedArtifactFingerprint = parsePreparedFingerprint(record.preparedArtifactFingerprint);
+	const claimedAtMs = parseTimestamp(record.claimedAtMs);
+	const prepared = parsePrepared(record.prepared);
+	if (requestFingerprint === null || preparedArtifactFingerprint === null || claimedAtMs === null || prepared === null) return null;
+	return {
 		requestFingerprint,
 		preparedArtifactFingerprint,
 		claimedAtMs,
-		completedAtMs,
-		prepared,
-		response
+		prepared
 	};
 }
 /**
@@ -403,10 +391,6 @@ function readRouterAbEd25519YaoRegistrationSideEffectRecordObjectV1(value) {
 function isRouterAbEd25519YaoRegistrationSideEffectRecordObjectV1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function hasExactRouterAbEd25519YaoRegistrationSideEffectRecordKeys(record, expectedKeys) {
-	const actualKeys = Object.keys(record);
-	return actualKeys.length === expectedKeys.length && actualKeys.every((key) => expectedKeys.some((expectedKey) => expectedKey === key));
-}
 function parseFingerprint(value) {
 	return typeof value === "string" && /^[a-zA-Z0-9_-]{32,128}$/u.test(value) ? value : null;
 }

package/dist/esm/router/domains/ed25519Yao/registration/routerAbEd25519YaoRegistrationTwoPhaseRunner.js

@@ -13,7 +13,7 @@ async function runRouterAbEd25519YaoRegistrationTwoPhaseV1(input) {
 		case "completed": return prepared;
 		case "rejected": return prepared;
 		case "claimed": {
-			const preclaim = await input.store.commit(buildCommitInput(input.lifecycleId, loaded, prepared.state));
+			const preclaim = await input.store.commit(buildCommitInput(input.lifecycleId, loaded, prepared.state, null));
 			if (preclaim.kind === "version_mismatch") return {
 				kind: "preclaim_version_mismatch",
 				key: preclaim.key
@@ -30,7 +30,7 @@ async function runRouterAbEd25519YaoRegistrationTwoPhaseV1(input) {
 				commit: preclaim
 			});
 			const completion = await input.complete(terminalSnapshot.state, prepared.claim, backend.value);
-			const terminal = await input.store.commit(buildCommitInput(input.lifecycleId, terminalSnapshot, completion.state));
+			const terminal = await input.store.commit(buildCommitInput(input.lifecycleId, terminalSnapshot, completion.state, completion.kind === "state_with_write" ? completion.write : null));
 			if (terminal.kind === "version_mismatch") return {
 				kind: "terminal_version_mismatch",
 				claim: prepared.claim,
@@ -45,11 +45,12 @@ async function runRouterAbEd25519YaoRegistrationTwoPhaseV1(input) {
 		}
 	}
 }
-function buildCommitInput(lifecycleId, loaded, state) {
+function buildCommitInput(lifecycleId, loaded, state, companionWrite) {
 	return {
 		lifecycleId,
 		state,
-		baseline: loaded.baseline
+		baseline: loaded.baseline,
+		companionWrite
 	};
 }
 //#endregion

package/dist/esm/router/domains/ed25519Yao/routerAbEd25519YaoGatewayEnvelope.js

@@ -0,0 +1,45 @@
+import { base64UrlDecode, base64UrlEncode } from "../../../shared-ts/src/utils/base64.js";
+import { decodeTenantRootIdentityWireV1 } from "../../../shared-ts/src/tenant-root/tenantRootIdentity.js";
+import { tenantRootIdentityDigestB64uV1 } from "../../cloudflare/runtime/tenantRootCreationGrant.js";
+//#region src/router/domains/ed25519Yao/routerAbEd25519YaoGatewayEnvelope.ts
+function parseRouterAbEd25519YaoTenantRootWireV1(input) {
+	if (typeof input !== "object" || input === null || Array.isArray(input)) return null;
+	const record = input;
+	if (Object.keys(record).length !== 2 || !Object.hasOwn(record, "identity") || !Object.hasOwn(record, "custody_lineage_b64u")) return null;
+	const identity = decodeTenantRootIdentityWireV1(record.identity);
+	const lineage = record.custody_lineage_b64u;
+	if (!identity.ok || typeof lineage !== "string" || !/^[A-Za-z0-9_-]+$/u.test(lineage)) return null;
+	try {
+		const bytes = base64UrlDecode(lineage);
+		if (bytes.length !== 16 || base64UrlEncode(bytes) !== lineage) return null;
+	} catch {
+		return null;
+	}
+	return {
+		identity: {
+			orgId: identity.value.orgId,
+			projectId: identity.value.projectId,
+			envId: identity.value.envId,
+			signingRootId: identity.value.signingRootId,
+			signingRootVersion: identity.value.signingRootVersion
+		},
+		custody_lineage_b64u: lineage
+	};
+}
+async function routerAbEd25519YaoTenantRootWireV1(root) {
+	if (await tenantRootIdentityDigestB64uV1(root.identity) !== root.identityDigestB64u) throw new Error("Resolved Yao tenant-root identity differs from its active lineage");
+	return {
+		identity: {
+			orgId: root.identity.orgId,
+			projectId: root.identity.projectId,
+			envId: root.identity.envId,
+			signingRootId: root.identity.signingRootId,
+			signingRootVersion: root.identity.signingRootVersion
+		},
+		custody_lineage_b64u: root.custodyLineageB64u
+	};
+}
+//#endregion
+export { parseRouterAbEd25519YaoTenantRootWireV1, routerAbEd25519YaoTenantRootWireV1 };
+
+//# sourceMappingURL=routerAbEd25519YaoGatewayEnvelope.js.map

package/dist/esm/router/domains/ed25519Yao/session/thresholdEd25519RequestValidation.js

@@ -270,6 +270,6 @@ function parseThresholdEd25519OperationStepUpGrantRequest(raw) {
 	}
 }
 //#endregion
-export { parseRouterAbEd25519YaoSessionPolicyV1, parseThresholdEd25519OperationStepUpGrantRequest, parseThresholdEd25519SessionRouteRequest };
+export { parseThresholdEd25519OperationStepUpGrantRequest, parseThresholdEd25519SessionRouteRequest };
 
 //# sourceMappingURL=thresholdEd25519RequestValidation.js.map

package/dist/esm/router/domains/emailOtp/emailOtpExportPolicy.js

@@ -23,48 +23,7 @@ async function authorizeEmailOtpExportPolicy(opts, input) {
 		policySource: "adapter"
 	};
 }
-function emailOtpExportPolicyAuditPayload(input) {
-	const decision = input.decision;
-	return {
-		source: input.source,
-		operation: WALLET_EMAIL_OTP_EXPORT_OPERATION,
-		policyDecision: decision.decision,
-		policySource: decision.policySource,
-		...decision.policyId ? { policyId: decision.policyId } : {},
-		...decision.approvalId ? { approvalId: decision.approvalId } : {},
-		...decision.reason ? { reason: decision.reason } : {},
-		...input.challengeId ? { challengeId: input.challengeId } : {},
-		...input.otpChannel ? { otpChannel: input.otpChannel } : {}
-	};
-}
-function emailOtpExportPolicyWebhookEventDescriptor(input) {
-	return {
-		eventType: input.eventType,
-		...input.challengeId ? { eventId: input.challengeId } : {},
-		payload: {
-			...emailOtpExportPolicyAuditPayload({
-				source: input.source,
-				decision: input.decision,
-				...input.challengeId ? { challengeId: input.challengeId } : {},
-				...input.otpChannel ? { otpChannel: input.otpChannel } : {}
-			}),
-			...input.code ? { code: input.code } : {},
-			...input.message ? { message: input.message } : {}
-		}
-	};
-}
-function emailOtpExportDeniedDecisionFromResult(input) {
-	return {
-		ok: false,
-		decision: "DENY",
-		code: input.code,
-		message: input.message,
-		policySource: input.policySource,
-		...input.policyId ? { policyId: input.policyId } : {},
-		...input.approvalId ? { approvalId: input.approvalId } : {}
-	};
-}
 //#endregion
-export { authorizeEmailOtpExportPolicy, emailOtpExportDeniedDecisionFromResult, emailOtpExportPolicyAuditPayload, emailOtpExportPolicyWebhookEventDescriptor };
+export { authorizeEmailOtpExportPolicy };
 
 //# sourceMappingURL=emailOtpExportPolicy.js.map

package/dist/esm/router/domains/emailOtp/emailOtpRequestValidation.js

@@ -7,11 +7,6 @@ function parseWalletUnlockBackend(raw) {
 	if (isWalletUnlockBackend(value)) return value;
 	return null;
 }
-function parseWalletEmailOtpChannel(raw) {
-	const value = normalizeOptionalTrimmedString(raw)?.toLowerCase() || "";
-	if (value === "email_otp") return value;
-	return null;
-}
 function parseWalletEmailOtpLoginOperation(raw) {
 	const value = normalizeOptionalTrimmedString(raw)?.toLowerCase() || "";
 	if (!value || value === "wallet_unlock") return {
@@ -29,6 +24,6 @@ function parseWalletEmailOtpLoginOperation(raw) {
 	};
 }
 //#endregion
-export { parseWalletEmailOtpChannel, parseWalletEmailOtpLoginOperation, parseWalletUnlockBackend };
+export { parseWalletEmailOtpLoginOperation, parseWalletUnlockBackend };
 
 //# sourceMappingURL=emailOtpRequestValidation.js.map