@seams/wallet-server 0.6.1 → 0.7.1

package/dist/esm/localIntendedRevokeFault.js

@@ -0,0 +1,106 @@
+import { isLocalIntendedYaoFaultTokenV1 } from "./localIntendedYaoFault.js";
+//#region src/localIntendedRevokeFault.ts
+const LOCAL_INTENDED_REVOKE_FAULT_HEADER_V1 = "x-seams-intended-revoke-fault-v1";
+const LOCAL_INTENDED_REVOKE_FAULT_TOKEN_HEADER_V1 = "x-seams-intended-revoke-fault-token-v1";
+const LOCAL_INTENDED_REVOKE_FAULT_PROOF_HEADER_V1 = "x-seams-intended-revoke-fault-proof-v1";
+const WALLET_REVOKE_AUTH_METHOD_PATH_PATTERN_V1 = /^\/wallets\/[^/]+\/auth-methods\/[^/]+\/revoke$/;
+/** A linked device's method, revoked through device management. */
+const LINKED_DEVICE_REVOKE_PATH_PATTERN_V1 = /^\/wallet\/device-linking\/v1\/devices\/[^/]+\/revoke$/;
+const RECORD_ANSWER_PATTERN = /^\s*INSERT OR IGNORE INTO wallet_auth_method_revocation_replays\b/;
+const SPEND_CODE_PATTERN = /^\s*DELETE FROM email_otp_challenges\b[\s\S]*\bchallenge_id = \?/;
+function parseLocalIntendedRevokeFaultModeV1(value) {
+	return value === "refuse_revocation_batch_once" ? value : null;
+}
+function parseLocalIntendedRevokeFaultTokenV1(value) {
+	return isLocalIntendedYaoFaultTokenV1(value) ? value : null;
+}
+/** The signer database, refusing one auth-method revocation's batch. */
+var LocalIntendedRevokeFaultDatabaseV1 = class {
+	constructor(base) {
+		this.base = base;
+		this.state = { kind: "armed" };
+	}
+	prepare(query) {
+		return new LocalIntendedRevokeFaultStatementV1(this, RECORD_ANSWER_PATTERN.test(query), SPEND_CODE_PATTERN.test(query), this.base.prepare(query));
+	}
+	async batch(statements) {
+		const faulted = statements.filter((statement) => statement instanceof LocalIntendedRevokeFaultStatementV1);
+		if (!faulted.some((statement) => statement.recordsAnswer)) return await this.base.batch(statements.map(unwrapStatement));
+		if (this.state.kind === "armed") this.state = {
+			kind: "proved",
+			proof: faulted.some((statement) => statement.spendsCode) ? "refused_revocation_with_its_code" : "refused_revocation_without_code"
+		};
+		else if (this.state.kind === "proved") this.state = {
+			kind: "violated",
+			violation: "additional_revocation_batch"
+		};
+		throw new Error("Local intended fault: the auth-method revocation batch did not commit");
+	}
+	async exec(query) {
+		return await this.base.exec(query);
+	}
+	spentCodeOutsideRevocation() {
+		this.state = {
+			kind: "violated",
+			violation: "code_spent_outside_revocation"
+		};
+	}
+	outcome() {
+		switch (this.state.kind) {
+			case "proved":
+			case "violated": return this.state;
+			case "armed": return {
+				kind: "violated",
+				violation: "revocation_batch_not_observed"
+			};
+		}
+	}
+};
+var LocalIntendedRevokeFaultStatementV1 = class LocalIntendedRevokeFaultStatementV1 {
+	constructor(database, recordsAnswer, spendsCode, inner) {
+		this.database = database;
+		this.recordsAnswer = recordsAnswer;
+		this.spendsCode = spendsCode;
+		this.inner = inner;
+	}
+	bind(...values) {
+		return new LocalIntendedRevokeFaultStatementV1(this.database, this.recordsAnswer, this.spendsCode, this.inner.bind(...values));
+	}
+	async first(columnName) {
+		this.observeOwnRun();
+		return await this.inner.first(columnName);
+	}
+	async all() {
+		this.observeOwnRun();
+		return await this.inner.all();
+	}
+	async run() {
+		this.observeOwnRun();
+		return await this.inner.run();
+	}
+	observeOwnRun() {
+		if (this.spendsCode) this.database.spentCodeOutsideRevocation();
+	}
+};
+function unwrapStatement(statement) {
+	return statement instanceof LocalIntendedRevokeFaultStatementV1 ? statement.inner : statement;
+}
+function requestWithoutLocalIntendedRevokeFaultHeadersV1(request) {
+	const headers = new Headers(request.headers);
+	headers.delete(LOCAL_INTENDED_REVOKE_FAULT_HEADER_V1);
+	headers.delete(LOCAL_INTENDED_REVOKE_FAULT_TOKEN_HEADER_V1);
+	return new Request(request, { headers });
+}
+function responseWithLocalIntendedRevokeFaultOutcomeV1(response, outcome, token) {
+	const headers = new Headers(response.headers);
+	headers.set(LOCAL_INTENDED_REVOKE_FAULT_PROOF_HEADER_V1, outcome.kind === "proved" ? `${token}:${outcome.proof}` : `${token}:violation:${outcome.violation}`);
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+//#endregion
+export { LINKED_DEVICE_REVOKE_PATH_PATTERN_V1, LOCAL_INTENDED_REVOKE_FAULT_HEADER_V1, LOCAL_INTENDED_REVOKE_FAULT_TOKEN_HEADER_V1, LocalIntendedRevokeFaultDatabaseV1, WALLET_REVOKE_AUTH_METHOD_PATH_PATTERN_V1, parseLocalIntendedRevokeFaultModeV1, parseLocalIntendedRevokeFaultTokenV1, requestWithoutLocalIntendedRevokeFaultHeadersV1, responseWithLocalIntendedRevokeFaultOutcomeV1 };
+
+//# sourceMappingURL=localIntendedRevokeFault.js.map

package/dist/esm/localIntendedSessionAdmissionFault.js

@@ -0,0 +1,139 @@
+import { isLocalIntendedYaoFaultTokenV1 } from "./localIntendedYaoFault.js";
+//#region src/localIntendedSessionAdmissionFault.ts
+const LOCAL_INTENDED_SESSION_ADMISSION_FAULT_HEADER_V1 = "x-seams-intended-session-admission-fault-v1";
+const LOCAL_INTENDED_SESSION_ADMISSION_FAULT_TOKEN_HEADER_V1 = "x-seams-intended-session-admission-fault-token-v1";
+const LOCAL_INTENDED_SESSION_ADMISSION_FAULT_PROOF_HEADER_V1 = "x-seams-intended-session-admission-fault-proof-v1";
+/** The ECDSA signing prepare: it admits the Wallet Session's operation credential. */
+const ECDSA_SIGN_PREPARE_PATH_V1 = "/router-ab/ecdsa-derivation/sign/prepare";
+const SESSION_READ_PATTERN = /FROM wallet_session_authorizations_v2 AS session[\s\S]*\bsession\.operation_credential_hash = \?/;
+const HOLD_LIMIT_MS = 6e4;
+const POLL_INTERVAL_MS = 50;
+function parseLocalIntendedSessionAdmissionFaultModeV1(value) {
+	return value === "hold_after_session_read_until_authority_changes" ? value : null;
+}
+function parseLocalIntendedSessionAdmissionFaultTokenV1(value) {
+	return isLocalIntendedYaoFaultTokenV1(value) ? value : null;
+}
+/** The signer database, holding one request after its session read. */
+var LocalIntendedSessionAdmissionFaultDatabaseV1 = class {
+	constructor(base) {
+		this.base = base;
+		this.state = { kind: "armed" };
+	}
+	prepare(query) {
+		const inner = this.base.prepare(query);
+		return SESSION_READ_PATTERN.test(query) ? new LocalIntendedSessionReadStatementV1(this, inner) : inner;
+	}
+	async batch(statements) {
+		return await this.base.batch(statements.map(unwrapStatement));
+	}
+	async exec(query) {
+		return await this.base.exec(query);
+	}
+	async holdAfterSessionRead(row) {
+		if (this.state.kind !== "armed") return;
+		const authority = readAuthorityOfSessionRow(row);
+		if (!authority) {
+			this.state = {
+				kind: "violated",
+				violation: "session_read_not_observed"
+			};
+			return;
+		}
+		const deadline = Date.now() + HOLD_LIMIT_MS;
+		while (Date.now() < deadline) {
+			await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+			const current = await this.base.prepare(`SELECT authority_digest_b64u
+             FROM wallet_authorities
+            WHERE namespace = ? AND org_id = ? AND project_id = ? AND env_id = ?
+              AND authority_id = ?
+            LIMIT 1`).bind(authority.namespace, authority.orgId, authority.projectId, authority.envId, authority.authorityId).first();
+			if (current && current.authority_digest_b64u !== authority.digest) {
+				this.state = {
+					kind: "proved",
+					proof: "held_until_authority_changed"
+				};
+				return;
+			}
+		}
+		this.state = {
+			kind: "violated",
+			violation: "authority_unchanged"
+		};
+	}
+	outcome() {
+		switch (this.state.kind) {
+			case "proved":
+			case "violated": return this.state;
+			case "armed": return {
+				kind: "violated",
+				violation: "session_read_not_observed"
+			};
+		}
+	}
+};
+var LocalIntendedSessionReadStatementV1 = class LocalIntendedSessionReadStatementV1 {
+	constructor(database, inner) {
+		this.database = database;
+		this.inner = inner;
+	}
+	bind(...values) {
+		return new LocalIntendedSessionReadStatementV1(this.database, this.inner.bind(...values));
+	}
+	async first(columnName) {
+		const row = await this.inner.first(columnName);
+		await this.database.holdAfterSessionRead(row);
+		return row;
+	}
+	async all() {
+		return await this.inner.all();
+	}
+	async run() {
+		return await this.inner.run();
+	}
+};
+/** The joined row carries the authority as it was read with the session. */
+function readAuthorityOfSessionRow(row) {
+	if (!row || typeof row !== "object") return null;
+	const value = row;
+	const fields = [
+		value.namespace,
+		value.org_id,
+		value.project_id,
+		value.env_id,
+		value.authority_id,
+		value.authority_digest_b64u
+	];
+	if (!fields.every((field) => typeof field === "string" && field.length > 0)) return null;
+	const [namespace, orgId, projectId, envId, authorityId, digest] = fields;
+	return {
+		namespace,
+		orgId,
+		projectId,
+		envId,
+		authorityId,
+		digest
+	};
+}
+function unwrapStatement(statement) {
+	return statement instanceof LocalIntendedSessionReadStatementV1 ? statement.inner : statement;
+}
+function requestWithoutLocalIntendedSessionAdmissionFaultHeadersV1(request) {
+	const headers = new Headers(request.headers);
+	headers.delete(LOCAL_INTENDED_SESSION_ADMISSION_FAULT_HEADER_V1);
+	headers.delete(LOCAL_INTENDED_SESSION_ADMISSION_FAULT_TOKEN_HEADER_V1);
+	return new Request(request, { headers });
+}
+function responseWithLocalIntendedSessionAdmissionFaultOutcomeV1(response, outcome, token) {
+	const headers = new Headers(response.headers);
+	headers.set(LOCAL_INTENDED_SESSION_ADMISSION_FAULT_PROOF_HEADER_V1, outcome.kind === "proved" ? `${token}:${outcome.proof}` : `${token}:violation:${outcome.violation}`);
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+//#endregion
+export { ECDSA_SIGN_PREPARE_PATH_V1, LOCAL_INTENDED_SESSION_ADMISSION_FAULT_HEADER_V1, LOCAL_INTENDED_SESSION_ADMISSION_FAULT_PROOF_HEADER_V1, LOCAL_INTENDED_SESSION_ADMISSION_FAULT_TOKEN_HEADER_V1, LocalIntendedSessionAdmissionFaultDatabaseV1, parseLocalIntendedSessionAdmissionFaultModeV1, parseLocalIntendedSessionAdmissionFaultTokenV1, requestWithoutLocalIntendedSessionAdmissionFaultHeadersV1, responseWithLocalIntendedSessionAdmissionFaultOutcomeV1 };
+
+//# sourceMappingURL=localIntendedSessionAdmissionFault.js.map

package/dist/esm/localIntendedYaoExportFault.js

@@ -0,0 +1,117 @@
+import { isLocalIntendedYaoFaultTokenV1 } from "./localIntendedYaoFault.js";
+//#region src/localIntendedYaoExportFault.ts
+const LOCAL_INTENDED_YAO_EXPORT_FAULT_HEADER_V1 = "x-seams-intended-yao-export-fault-v1";
+const LOCAL_INTENDED_YAO_EXPORT_FAULT_TOKEN_HEADER_V1 = "x-seams-intended-yao-export-fault-token-v1";
+const LOCAL_INTENDED_YAO_FAULT_PROOF_HEADER_V1 = "x-seams-intended-yao-fault-proof-v1";
+const AUTHORIZED_OPERATION_INSERT_PATTERN = /^\s*INSERT INTO authorized_operations\b/;
+const STATE_RECORD_WRITE_PATTERN = /^\s*(?:INSERT OR IGNORE INTO|UPDATE)\s+router_ab_yao_versioned_json_records\b/;
+function parseLocalIntendedYaoExportFaultModeV1(value) {
+	return value === "lose_storage_after_export_authorization_once" ? value : null;
+}
+function parseLocalIntendedYaoExportFaultTokenV1(value) {
+	return isLocalIntendedYaoFaultTokenV1(value) ? value : null;
+}
+/** The signer database, losing itself once after an export authorization commits. */
+var LocalIntendedYaoExportFaultDatabaseV1 = class {
+	constructor(base) {
+		this.base = base;
+		this.state = { kind: "armed" };
+	}
+	prepare(query) {
+		return new LocalIntendedYaoExportFaultStatementV1(this, statementRole(query), this.base.prepare(query));
+	}
+	async batch(statements) {
+		this.loseStorageIfAuthorized();
+		const roles = new Set(statements.map(roleOf));
+		const results = await this.base.batch(statements.map(unwrapStatement));
+		if (roles.has("authorized_operation") && roles.has("state_record") && this.state.kind === "armed") this.state = { kind: "authorized" };
+		return results;
+	}
+	async exec(query) {
+		this.loseStorageIfAuthorized();
+		return await this.base.exec(query);
+	}
+	loseStorageIfAuthorized() {
+		if (this.state.kind !== "authorized") return;
+		this.state = { kind: "lost" };
+		throw new Error("Local intended fault: the Gateway lost its storage after an Ed25519 Yao export authorization committed");
+	}
+	/** The fault's outcome, from whether each of the two identical requests was admitted. */
+	outcome(answers) {
+		switch (this.state.kind) {
+			case "armed": return {
+				kind: "violated",
+				violation: "export_authorization_not_committed"
+			};
+			case "authorized": return {
+				kind: "violated",
+				violation: "no_storage_call_after_authorization"
+			};
+			case "lost": break;
+		}
+		if (answers.interruptedOk) return {
+			kind: "violated",
+			violation: "interrupted_admission_answered"
+		};
+		if (!answers.retriedOk) return {
+			kind: "violated",
+			violation: "retried_admission_failed"
+		};
+		return {
+			kind: "proved",
+			proof: "export_authorization_committed_then_storage_lost"
+		};
+	}
+};
+var LocalIntendedYaoExportFaultStatementV1 = class LocalIntendedYaoExportFaultStatementV1 {
+	constructor(database, role, inner) {
+		this.database = database;
+		this.role = role;
+		this.inner = inner;
+	}
+	bind(...values) {
+		return new LocalIntendedYaoExportFaultStatementV1(this.database, this.role, this.inner.bind(...values));
+	}
+	async first(columnName) {
+		this.database.loseStorageIfAuthorized();
+		return await this.inner.first(columnName);
+	}
+	async all() {
+		this.database.loseStorageIfAuthorized();
+		return await this.inner.all();
+	}
+	async run() {
+		this.database.loseStorageIfAuthorized();
+		return await this.inner.run();
+	}
+};
+function statementRole(query) {
+	if (AUTHORIZED_OPERATION_INSERT_PATTERN.test(query)) return "authorized_operation";
+	if (STATE_RECORD_WRITE_PATTERN.test(query)) return "state_record";
+	return "other";
+}
+function roleOf(statement) {
+	return statement instanceof LocalIntendedYaoExportFaultStatementV1 ? statement.role : "other";
+}
+function unwrapStatement(statement) {
+	return statement instanceof LocalIntendedYaoExportFaultStatementV1 ? statement.inner : statement;
+}
+function requestWithoutLocalIntendedYaoExportFaultHeadersV1(request) {
+	const headers = new Headers(request.headers);
+	headers.delete(LOCAL_INTENDED_YAO_EXPORT_FAULT_HEADER_V1);
+	headers.delete(LOCAL_INTENDED_YAO_EXPORT_FAULT_TOKEN_HEADER_V1);
+	return new Request(request, { headers });
+}
+function responseWithLocalIntendedYaoExportFaultOutcomeV1(response, outcome, token) {
+	const headers = new Headers(response.headers);
+	headers.set(LOCAL_INTENDED_YAO_FAULT_PROOF_HEADER_V1, outcome.kind === "proved" ? `${token}:${outcome.proof}` : `${token}:violated:${outcome.violation}`);
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+//#endregion
+export { LOCAL_INTENDED_YAO_EXPORT_FAULT_HEADER_V1, LOCAL_INTENDED_YAO_EXPORT_FAULT_TOKEN_HEADER_V1, LocalIntendedYaoExportFaultDatabaseV1, parseLocalIntendedYaoExportFaultModeV1, parseLocalIntendedYaoExportFaultTokenV1, requestWithoutLocalIntendedYaoExportFaultHeadersV1, responseWithLocalIntendedYaoExportFaultOutcomeV1 };
+
+//# sourceMappingURL=localIntendedYaoExportFault.js.map

package/dist/esm/localIntendedYaoFault.js

@@ -6,7 +6,7 @@ const LOCAL_INTENDED_YAO_FAULT_PROOF_HEADER_V1 = "x-seams-intended-yao-fault-pro
 const ROUTER_AB_YAO_REPLAY_HEADER_V1 = "x-seams-yao-replay";
 const ROUTER_AB_YAO_EXECUTE_PATH_V1 = "/router-ab/router/ed25519-yao/execute";
 const LOCAL_INTENDED_YAO_FAULT_TOKEN_PATTERN_V1 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
-const LOCAL_INTENDED_BURNED_EXECUTION_ID_V1 = new Array(32).fill(93);
+const LOCAL_INTENDED_ROUTER_BURN_HEADER_V1 = "x-seams-local-intended-router-burn-v1";
 function equalRequestBytes(left, right) {
 	if (left.length !== right.length) return false;
 	for (let index = 0; index < left.length; index += 1) if (left[index] !== right[index]) return false;
@@ -26,16 +26,6 @@ function parseLocalIntendedYaoFaultTokenV1(value) {
 function isLocalIntendedYaoFaultTokenV1(value) {
 	return !!value && LOCAL_INTENDED_YAO_FAULT_TOKEN_PATTERN_V1.test(value);
 }
-function terminalBurnedRouterResponseV1() {
-	return new Response(JSON.stringify({
-		status: "burned",
-		execution_id: LOCAL_INTENDED_BURNED_EXECUTION_ID_V1,
-		reason: "protocol_failure"
-	}), {
-		status: 200,
-		headers: { "content-type": "application/json" }
-	});
-}
 var LocalIntendedYaoFaultControllerV1 = class {
 	constructor(baseFetch) {
 		this.baseFetch = baseFetch;
@@ -93,11 +83,18 @@ var LocalIntendedYaoFaultControllerV1 = class {
 	}
 	async handleArmedExecute(request, mode) {
 		if (mode === "return_terminal_burned_once") {
-			this.state = {
+			const headers = new Headers(request.headers);
+			headers.set(LOCAL_INTENDED_ROUTER_BURN_HEADER_V1, "burned");
+			const response = await this.baseFetch.call(globalThis, new Request(request, { headers }));
+			const answer = await response.clone().json().catch(() => null);
+			this.state = response.ok && answer?.status === "burned" ? {
 				kind: "proved",
 				proof: "terminal_failure_not_retried"
+			} : {
+				kind: "violated",
+				violation: "router_terminal_not_recorded"
 			};
-			return terminalBurnedRouterResponseV1();
+			return response;
 		}
 		const body = new Uint8Array(await request.clone().arrayBuffer());
 		const traceId = request.headers.get("x-seams-trace-id") ?? "";
@@ -133,12 +130,12 @@ var LocalIntendedYaoFaultControllerV1 = class {
 			};
 			throw new Error("Local intended Yao retry changed the Router trace ID");
 		}
-		if (request.headers.get(ROUTER_AB_YAO_REPLAY_HEADER_V1) !== "1") {
+		if (request.headers.has(ROUTER_AB_YAO_REPLAY_HEADER_V1)) {
 			this.state = {
 				kind: "violated",
-				violation: "router_retry_marker_missing"
+				violation: "router_retry_marked_as_replay"
 			};
-			throw new Error("Local intended Yao retry omitted the replay marker");
+			throw new Error("Local intended Yao retry carried the replay marker");
 		}
 		const response = await this.baseFetch.call(globalThis, request);
 		await response.clone().arrayBuffer();

package/dist/esm/localIntendedYaoFinalizeFault.js

@@ -0,0 +1,99 @@
+import { isLocalIntendedYaoFaultTokenV1 } from "./localIntendedYaoFault.js";
+//#region src/localIntendedYaoFinalizeFault.ts
+const LOCAL_INTENDED_YAO_FINALIZE_FAULT_HEADER_V1 = "x-seams-intended-yao-finalize-fault-v1";
+const LOCAL_INTENDED_YAO_FINALIZE_FAULT_TOKEN_HEADER_V1 = "x-seams-intended-yao-finalize-fault-token-v1";
+const LOCAL_INTENDED_YAO_FAULT_PROOF_HEADER_V1 = "x-seams-intended-yao-fault-proof-v1";
+const WALLET_REGISTRATION_NEAR_PROVISIONING_PATH_V1 = "/wallets/register/near-provisioning";
+const DECISION_INSERT_PATTERN = /^\s*INSERT OR IGNORE INTO yao_lifecycle_decisions\b/;
+function parseLocalIntendedYaoFinalizeFaultModeV1(value) {
+	return value === "lose_storage_after_decision_once" ? value : null;
+}
+function parseLocalIntendedYaoFinalizeFaultTokenV1(value) {
+	return isLocalIntendedYaoFaultTokenV1(value) ? value : null;
+}
+/** The signer database, losing itself once after a Yao decision commits. */
+var LocalIntendedYaoFinalizeFaultDatabaseV1 = class {
+	constructor(base) {
+		this.base = base;
+		this.state = { kind: "armed" };
+	}
+	prepare(query) {
+		return new LocalIntendedYaoFinalizeFaultStatementV1(this, DECISION_INSERT_PATTERN.test(query), this.base.prepare(query));
+	}
+	async batch(statements) {
+		this.loseStorageIfDecided();
+		const decides = statements.some((statement) => statement instanceof LocalIntendedYaoFinalizeFaultStatementV1 && statement.decides);
+		const results = await this.base.batch(statements.map(unwrapStatement));
+		if (decides && this.state.kind === "armed") this.state = { kind: "decided" };
+		return results;
+	}
+	async exec(query) {
+		this.loseStorageIfDecided();
+		return await this.base.exec(query);
+	}
+	loseStorageIfDecided() {
+		if (this.state.kind !== "decided") return;
+		this.state = { kind: "proved" };
+		throw new Error("Local intended fault: the Gateway lost its storage after an Ed25519 Yao decision committed");
+	}
+	outcome() {
+		switch (this.state.kind) {
+			case "proved": return {
+				kind: "proved",
+				proof: "decision_committed_then_storage_lost"
+			};
+			case "decided": return {
+				kind: "violated",
+				violation: "no_storage_call_after_decision"
+			};
+			case "armed": return {
+				kind: "violated",
+				violation: "decision_not_committed"
+			};
+		}
+	}
+};
+var LocalIntendedYaoFinalizeFaultStatementV1 = class LocalIntendedYaoFinalizeFaultStatementV1 {
+	constructor(database, decides, inner) {
+		this.database = database;
+		this.decides = decides;
+		this.inner = inner;
+	}
+	bind(...values) {
+		return new LocalIntendedYaoFinalizeFaultStatementV1(this.database, this.decides, this.inner.bind(...values));
+	}
+	async first(columnName) {
+		this.database.loseStorageIfDecided();
+		return await this.inner.first(columnName);
+	}
+	async all() {
+		this.database.loseStorageIfDecided();
+		return await this.inner.all();
+	}
+	async run() {
+		this.database.loseStorageIfDecided();
+		return await this.inner.run();
+	}
+};
+function unwrapStatement(statement) {
+	return statement instanceof LocalIntendedYaoFinalizeFaultStatementV1 ? statement.inner : statement;
+}
+function requestWithoutLocalIntendedYaoFinalizeFaultHeadersV1(request) {
+	const headers = new Headers(request.headers);
+	headers.delete(LOCAL_INTENDED_YAO_FINALIZE_FAULT_HEADER_V1);
+	headers.delete(LOCAL_INTENDED_YAO_FINALIZE_FAULT_TOKEN_HEADER_V1);
+	return new Request(request, { headers });
+}
+function responseWithLocalIntendedYaoFinalizeFaultOutcomeV1(response, outcome, token) {
+	const headers = new Headers(response.headers);
+	headers.set(LOCAL_INTENDED_YAO_FAULT_PROOF_HEADER_V1, outcome.kind === "proved" ? `${token}:${outcome.proof}` : `${token}:violated:${outcome.violation}`);
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+//#endregion
+export { LOCAL_INTENDED_YAO_FINALIZE_FAULT_HEADER_V1, LOCAL_INTENDED_YAO_FINALIZE_FAULT_TOKEN_HEADER_V1, LocalIntendedYaoFinalizeFaultDatabaseV1, WALLET_REGISTRATION_NEAR_PROVISIONING_PATH_V1, parseLocalIntendedYaoFinalizeFaultModeV1, parseLocalIntendedYaoFinalizeFaultTokenV1, requestWithoutLocalIntendedYaoFinalizeFaultHeadersV1, responseWithLocalIntendedYaoFinalizeFaultOutcomeV1 };
+
+//# sourceMappingURL=localIntendedYaoFinalizeFault.js.map

package/dist/esm/localIntendedYaoRecoveryFault.js

@@ -0,0 +1,102 @@
+import { isLocalIntendedYaoFaultTokenV1 } from "./localIntendedYaoFault.js";
+//#region src/localIntendedYaoRecoveryFault.ts
+const LOCAL_INTENDED_YAO_RECOVERY_FAULT_HEADER_V1 = "x-seams-intended-yao-recovery-fault-v1";
+const LOCAL_INTENDED_YAO_RECOVERY_FAULT_TOKEN_HEADER_V1 = "x-seams-intended-yao-recovery-fault-token-v1";
+const LOCAL_INTENDED_YAO_FAULT_PROOF_HEADER_V1 = "x-seams-intended-yao-fault-proof-v1";
+const ROUTER_AB_YAO_EXECUTE_PATH_V1 = "/router-ab/router/ed25519-yao/execute";
+const keptRecoveryExecutes = /* @__PURE__ */ new Map();
+function parseLocalIntendedYaoRecoveryFaultModeV1(value) {
+	switch (value) {
+		case "lose_router_recovery_replies":
+		case "withhold_router_recovery_execute":
+		case "release_router_recovery_execute": return value;
+		default: return null;
+	}
+}
+function parseLocalIntendedYaoRecoveryFaultTokenV1(value) {
+	return isLocalIntendedYaoFaultTokenV1(value) ? value : null;
+}
+/** The Gateway's Router binding, faulting every call to a recovery execution. */
+var LocalIntendedYaoRecoveryFaultControllerV1 = class {
+	constructor(baseFetch, mode, token) {
+		this.baseFetch = baseFetch;
+		this.mode = mode;
+		this.token = token;
+		this.executed = false;
+		this.failed = false;
+		this.kept = false;
+	}
+	async fetch(input, init) {
+		const request = new Request(input, init);
+		if (request.method !== "POST" || new URL(request.url).pathname !== ROUTER_AB_YAO_EXECUTE_PATH_V1) return await this.baseFetch.call(globalThis, request);
+		if (this.mode === "withhold_router_recovery_execute") {
+			if (!keptRecoveryExecutes.has(this.token)) keptRecoveryExecutes.set(this.token, {
+				url: request.url,
+				headers: [...request.headers],
+				body: await request.clone().text()
+			});
+			this.kept = true;
+			throw new Error("Local intended Yao recovery fault withheld the Router execution");
+		}
+		const response = await this.baseFetch.call(globalThis, request);
+		const answer = await response.clone().json().catch(() => null);
+		if (response.ok && typeof answer === "object" && answer !== null && answer.status === "succeeded") this.executed = true;
+		else this.failed = true;
+		throw new Error("Local intended Yao recovery fault lost the Router reply");
+	}
+	outcome() {
+		if (this.mode === "withhold_router_recovery_execute") return this.kept ? {
+			kind: "proved",
+			proof: "recovery_execute_withheld"
+		} : {
+			kind: "violated",
+			violation: "router_recovery_execute_not_observed"
+		};
+		if (this.failed) return {
+			kind: "violated",
+			violation: "router_recovery_answer_failed"
+		};
+		if (!this.executed) return {
+			kind: "violated",
+			violation: "router_recovery_not_executed"
+		};
+		return {
+			kind: "proved",
+			proof: "recovery_replies_lost_after_router_executed"
+		};
+	}
+};
+/** Sends the execution kept under `token` to the Router, exactly. */
+async function releaseLocalIntendedYaoRecoveryExecuteV1(router, token) {
+	const kept = keptRecoveryExecutes.get(token);
+	if (!kept) return Response.json({ code: "intended_recovery_execute_missing" }, { status: 404 });
+	keptRecoveryExecutes.delete(token);
+	const reply = await router.fetch(new Request(kept.url, {
+		method: "POST",
+		headers: kept.headers.map(([name, value]) => [name, value]),
+		body: kept.body
+	}));
+	return Response.json({
+		status: reply.status,
+		body: await reply.text()
+	});
+}
+function requestWithoutLocalIntendedYaoRecoveryFaultHeadersV1(request) {
+	const headers = new Headers(request.headers);
+	headers.delete(LOCAL_INTENDED_YAO_RECOVERY_FAULT_HEADER_V1);
+	headers.delete(LOCAL_INTENDED_YAO_RECOVERY_FAULT_TOKEN_HEADER_V1);
+	return new Request(request, { headers });
+}
+function responseWithLocalIntendedYaoRecoveryFaultOutcomeV1(response, outcome, token) {
+	const headers = new Headers(response.headers);
+	headers.set(LOCAL_INTENDED_YAO_FAULT_PROOF_HEADER_V1, outcome.kind === "proved" ? `${token}:${outcome.proof}` : `${token}:violated:${outcome.violation}`);
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+//#endregion
+export { LOCAL_INTENDED_YAO_RECOVERY_FAULT_HEADER_V1, LOCAL_INTENDED_YAO_RECOVERY_FAULT_TOKEN_HEADER_V1, LocalIntendedYaoRecoveryFaultControllerV1, parseLocalIntendedYaoRecoveryFaultModeV1, parseLocalIntendedYaoRecoveryFaultTokenV1, releaseLocalIntendedYaoRecoveryExecuteV1, requestWithoutLocalIntendedYaoRecoveryFaultHeadersV1, responseWithLocalIntendedYaoRecoveryFaultOutcomeV1 };
+
+//# sourceMappingURL=localIntendedYaoRecoveryFault.js.map