@oaath/server 0.1.0 → 0.3.1

package/dist/service-Cf4f-9KP.js

@@ -0,0 +1,706 @@
+import { b as relayFailure, c as canonicalIdentifier, m as timestamp, o as RELAY_LIMITS, r as OAATH_AUTHORIZATION_REQUEST_RECORD_VERSION, s as boundedText } from "./records-BQNDxbPg.js";
+import { a as relayNow, n as randomIdentifier, r as sha256Base64Url, t as isCodeChallengeS256 } from "./challenge-DmpGSogj.js";
+import { n as OAATH_REVOCATION_REQUEST_RECORD_VERSION, r as REVOCATION_OPERATION_PREFIX, t as OAATH_REVOCATION_DECISION_RECORD_VERSION } from "./records-BUvqmp0D.js";
+import { applyPermissionDecision, captureRecord, createGrantFromPermissionRequest, exactRecord, hashKernelRevocationSigningRequest, hashOwnerSigningRequest, hashPermissionRequest, isKernelExistingAccountProfile, parseKernelReplayableInstallOwnerSigningRequest, parseKernelRevocationSigningRequest, parseOwnerSigningArtifact, parseOwnerSigningRequest, parsePermissionDecision, parsePermissionRequest, sameOwnerCredentialProfile, serializeOwnerSigningArtifact } from "@oaath/protocol";
+import { p256 } from "@noble/curves/nist.js";
+import { hexToBytes } from "@noble/hashes/utils.js";
+//#region src/store/interface.ts
+/**
+* Runs one transition inside one transaction. The body commits, or the
+* transaction is rolled back and the canonical failure is preserved.
+*/
+async function withRelayTransaction(store, run) {
+	const transaction = await store.begin();
+	let result;
+	try {
+		result = await run(transaction);
+	} catch (error) {
+		await transaction.rollback();
+		throw error;
+	}
+	await transaction.commit();
+	return result;
+}
+//#endregion
+//#region src/artifact/encrypt.ts
+/**
+* KMS sealing boundary. Plaintext never reaches the store.
+*
+* @author taek <leekt216@gmail.com>
+*/
+const KMS_UNAVAILABLE = "relay_kms_unavailable";
+/**
+* Encrypts an approval artifact and returns the opaque reference to store.
+* A port that echoes plaintext is rejected: the store must never hold it.
+*/
+async function sealArtifact(kms, plaintext) {
+	let sealed;
+	try {
+		sealed = await kms.encrypt(plaintext);
+	} catch {
+		return relayFailure(KMS_UNAVAILABLE, "KMS encrypt failed");
+	}
+	const ciphertextRef = boundedText(sealed, RELAY_LIMITS.ciphertextRef, "KMS ciphertext reference", KMS_UNAVAILABLE);
+	if (ciphertextRef.includes(plaintext)) return relayFailure(KMS_UNAVAILABLE, "KMS reference contains plaintext");
+	return ciphertextRef;
+}
+/**
+* Opens retained ciphertext for an authorized internal reader. Client release
+* calls this only after claim commits; authority verification releases no bytes.
+*/
+async function openArtifact(kms, ciphertextRef) {
+	let opened;
+	try {
+		opened = await kms.decrypt(ciphertextRef);
+	} catch {
+		return relayFailure(KMS_UNAVAILABLE, "KMS decrypt failed");
+	}
+	return boundedText(opened, RELAY_LIMITS.artifactPlaintext, "KMS plaintext", KMS_UNAVAILABLE);
+}
+//#endregion
+//#region src/authorization/approved-permission.ts
+/** Retained service-approved policy, independent of OAuth claim or execution expiry. */
+/**
+* The same protocol approval meaning at admission and after durable recovery.
+* Kernel capability verification belongs to the SDK; this owner checks the
+* decision's request binding, policy attenuation and reported decision time.
+* Evaluate at that time so a retained approval remains readable for revocation
+* after its execution or OAuth claim window has closed.
+*/
+function parseApprovedPermission(plaintext, permissionRequest, relayDecidedAt) {
+	const value = JSON.parse(plaintext);
+	const decisionValue = value !== null && typeof value === "object" && "installApproval" in value ? (({ installApproval: _install, ...permission }) => permission)(value) : value;
+	const permission = parsePermissionDecision(decisionValue);
+	if (permission.kind !== "approve" || permission.decidedAt > Math.floor(relayDecidedAt / 1e3)) throw new Error("permission artifact is not an approved decision at the relay decision time");
+	const applied = applyPermissionDecision({
+		request: permissionRequest,
+		grant: createGrantFromPermissionRequest(permissionRequest),
+		observation: {
+			status: "available",
+			decision: permission
+		},
+		evaluatedAt: permission.decidedAt
+	});
+	if (applied.status !== "applied" || applied.grant.state !== "approved") throw new Error("permission artifact does not approve this request");
+	return {
+		permission,
+		plaintext
+	};
+}
+/** Kernel capability verification remains the SDK preparation owner's responsibility. */
+async function readApprovedPermission(transaction, kms, request, decision, permissionRequest) {
+	try {
+		const artifact = await transaction.lockEncryptedArtifactByRequestId(request.requestId);
+		if (!artifact || artifact.requestId !== request.requestId || artifact.clientId !== request.clientId || artifact.createdAt !== decision.decidedAt) return null;
+		return parseApprovedPermission(await openArtifact(kms, artifact.ciphertextRef), permissionRequest, decision.decidedAt);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/authorization/owner-signing.ts
+/**
+* Pure authorization of one returned Kernel owner-signing artifact.
+*
+* The protocol owns both exact wire shapes. This server owner adds only the
+* release policy: the request must use the first-runtime P-256 credential, the
+* artifact must be its one canonical JSON representation, its request hash must
+* bind the exact request, and its compact low-S signature must verify the exact
+* Kernel digest. It allocates and persists nothing.
+*
+* @author taek <leekt216@gmail.com>
+*/
+const INVALID = "relay_request_invalid";
+/**
+* Returns the canonical artifact plaintext only after every request, key,
+* request-hash, and signature binding agrees.
+*/
+function verifyKernelV4ReplayableInstallOwnerSigningArtifact(requestValue, artifactPlaintext) {
+	try {
+		const request = parseKernelReplayableInstallOwnerSigningRequest(requestValue);
+		if (request.signer.ownerCredential.kind !== "p256") throw new TypeError();
+		return verifyArtifact(hashOwnerSigningRequest(request), request.expectedDigest, request.signer.ownerCredential.publicKey, artifactPlaintext);
+	} catch {
+		return relayFailure(INVALID, "Kernel owner signing artifact is invalid");
+	}
+}
+/** Stored signing request has already crossed the durable record boundary. */
+function verifyKernelV4RevocationOwnerSigningArtifact(request, artifactPlaintext) {
+	try {
+		if (request.install.signer.ownerCredential.kind !== "p256") throw new TypeError();
+		return verifyArtifact(hashKernelRevocationSigningRequest(request), request.expectedDigest, request.install.signer.ownerCredential.publicKey, artifactPlaintext);
+	} catch {
+		return relayFailure(INVALID, "Kernel owner signing artifact is invalid");
+	}
+}
+function verifyArtifact(requestHash, digest, publicKey, artifactPlaintext) {
+	const received = boundedText(artifactPlaintext, RELAY_LIMITS.artifactPlaintext, "owner signing artifact", INVALID);
+	const artifact = parseOwnerSigningArtifact(JSON.parse(received));
+	const canonical = serializeOwnerSigningArtifact(artifact);
+	if (received !== canonical) throw new TypeError();
+	if (artifact.requestHash !== requestHash) throw new TypeError();
+	if (!p256.verify(hexToBytes(artifact.signature.slice(2)), hexToBytes(digest.slice(2)), hexToBytes(publicKey.slice(2)), {
+		format: "compact",
+		lowS: true,
+		prehash: false
+	})) throw new TypeError();
+	return canonical;
+}
+//#endregion
+//#region src/native/display.ts
+/** Bounded base64url match code length. 48 bits is plenty to compare by eye. */
+const NATIVE_DISPLAY_PAYLOAD_LENGTH = 8;
+const NATIVE_DISPLAY_DOMAIN = "oaath.native-display/v1:";
+/** One non-secret comparison code for the requesting app, phone, inbox, and push. */
+async function ownerPhoneDisplayPayload(ownerSubject, operationId) {
+	return (await sha256Base64Url(`${NATIVE_DISPLAY_DOMAIN}${ownerSubject}:${operationId}`)).slice(0, 8);
+}
+//#endregion
+//#region src/authorization/request.ts
+/**
+* Create and read an authorization request.
+*
+* The request record snapshots the resolved approving device separately from
+* the requesting member. It is immutable once created; reads and decisions never
+* re-resolve the owner. A refused route creates no row. After a crash, the durable
+* route remains authoritative. Creation does not automatically retry writes.
+* Its decision is a separate terminal record, so "was this decided?" has one owner.
+*
+* @author taek <leekt216@gmail.com>
+*/
+async function createAuthorizationRequest(input) {
+	if (!isCodeChallengeS256(input.codeChallenge)) return relayFailure("relay_request_invalid", "codeChallenge must be an S256 challenge");
+	if (!input.caller.redirectUris.includes(input.redirectUri)) return relayFailure("relay_forbidden", "redirectUri is not registered for this client");
+	const requestId = randomIdentifier();
+	const resolved = await input.ownerRouting.resolveOwner(input.caller, Object.freeze({
+		requestId,
+		requestedScope: input.requestedScope
+	}));
+	if (resolved === null) return relayFailure("relay_forbidden", "no approving device is assigned");
+	const owner = exactRecord(resolved, ["ownerDeviceId", "ownerSubject"], "owner route", /* @__PURE__ */ new WeakSet(), (message) => relayFailure("relay_internal", message));
+	const ownerDeviceId = canonicalIdentifier(owner.ownerDeviceId, "ownerDeviceId", "relay_internal");
+	const ownerSubject = canonicalIdentifier(owner.ownerSubject, "ownerSubject", "relay_internal");
+	const createdAt = relayNow(input.clock);
+	const record = Object.freeze({
+		version: OAATH_AUTHORIZATION_REQUEST_RECORD_VERSION,
+		requestId,
+		clientId: input.caller.clientId,
+		subject: input.caller.subject,
+		ownerDeviceId,
+		ownerSubject,
+		organizationAudience: input.caller.organizationAudience,
+		redirectUri: input.redirectUri,
+		codeChallenge: input.codeChallenge,
+		requestedScope: input.requestedScope,
+		createdAt,
+		expiresAt: createdAt + input.requestTtlMs
+	});
+	const matchCode = await ownerPhoneDisplayPayload(ownerSubject, requestId);
+	await withRelayTransaction(input.store, async (transaction) => {
+		if (!await transaction.insertAuthorizationRequest(record)) return relayFailure("relay_internal", "authorization request identifier is not unique");
+	});
+	return Object.freeze({
+		requestId: record.requestId,
+		expiresAt: record.expiresAt,
+		matchCode
+	});
+}
+/**
+* Row-locked read of the request and its decision. Read paths take the same
+* exclusive lock as transitions.
+*
+* ponytail: one lock class for reads and writes; add a shared read mode only if
+* approval-screen traffic measurably contends.
+*/
+async function readAuthorizationState(transaction, requestId, now, match) {
+	const request = await transaction.lockAuthorizationRequest(requestId);
+	if (!request || !match(request)) return relayFailure("relay_not_found", "authorization request does not exist");
+	const decision = await transaction.lockAuthorizationDecision(requestId);
+	return Object.freeze({
+		requestId: request.requestId,
+		clientId: request.clientId,
+		redirectUri: request.redirectUri,
+		requestedScope: request.requestedScope,
+		expiresAt: request.expiresAt,
+		expired: now >= request.expiresAt,
+		decision: decision ? Object.freeze({
+			outcome: decision.outcome,
+			decidedAt: decision.decidedAt
+		}) : null
+	});
+}
+/** Read for the approving owner. */
+function fetchAuthorizationRequest(input) {
+	const now = relayNow(input.clock);
+	return withRelayTransaction(input.store, (transaction) => readAuthorizationState(transaction, input.requestId, now, (request) => request.ownerSubject === input.caller.subject));
+}
+//#endregion
+//#region src/authorization/scope.ts
+/**
+* Authoritative classification of one immutable stored authorization scope.
+*
+* The current server may approve an exact protocol PermissionRequest or the
+* one exact Kernel replayable-install request backed by a P-256 owner. Other
+* closed owner-signing requests are captured for projection and hashing but
+* remain reject-only. Unknown, malformed, and legacy scopes stay readable and
+* rejectable, but never authorize artifact creation.
+*
+* @author taek <leekt216@gmail.com>
+*/
+function classifyStoredAuthorizationScope(requestedScope, requestId) {
+	try {
+		const parsed = JSON.parse(requestedScope);
+		if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return Object.freeze({
+			kind: "unverified",
+			decision: "reject-only"
+		});
+		try {
+			return Object.freeze({
+				kind: "permission-request",
+				decision: "approve-or-reject",
+				request: parsePermissionRequest({
+					...parsed,
+					requestId
+				})
+			});
+		} catch {
+			const request = parseOwnerSigningRequest(parsed);
+			try {
+				const kernelRequest = parseKernelReplayableInstallOwnerSigningRequest(request);
+				if (kernelRequest.signer.ownerCredential.kind === "p256") return Object.freeze({
+					kind: "kernel-owner-signing-request",
+					decision: "approve-or-reject",
+					request: kernelRequest
+				});
+			} catch {}
+			return Object.freeze({
+				kind: "owner-signing-request",
+				decision: "reject-only",
+				request
+			});
+		}
+	} catch {
+		return Object.freeze({
+			kind: "unverified",
+			decision: "reject-only"
+		});
+	}
+}
+//#endregion
+//#region src/native/permission-approval.ts
+/** Canonical permission preparation supplied by the deployment's Kernel SDK integration. */
+async function prepareOwnerPhonePermissionApproval(provider, request) {
+	if (!provider) return relayFailure("relay_request_invalid", "phone permission signing is not configured");
+	const invalid = () => relayFailure("relay_request_invalid", "phone permission preparation is invalid");
+	const result = captureRecord(await provider.prepare(request), "phone permission preparation", /* @__PURE__ */ new WeakSet(), invalid);
+	const signingRequest = parseKernelReplayableInstallOwnerSigningRequest(result.signingRequest);
+	if (signingRequest.signer.ownerCredential.kind !== "p256" || !sameOwnerCredentialProfile(signingRequest.signer.ownerCredential, request.logicalAccount.ownerCredential) || typeof result.complete !== "function") return invalid();
+	const complete = result.complete;
+	const requestHash = hashOwnerSigningRequest(signingRequest);
+	return Object.freeze({
+		signingRequest,
+		async complete(artifact, decidedAt) {
+			if (artifact.requestHash !== requestHash) return invalid();
+			return boundedText(await complete(artifact, decidedAt), RELAY_LIMITS.artifactPlaintext, "permission artifact", "relay_request_invalid");
+		}
+	});
+}
+//#endregion
+//#region src/native/projection.ts
+/**
+* EXPERIMENTAL PREVIEW — authenticated owner-phone consent projection.
+*
+* This is a preview surface reached through `@oaath/server/native` and the
+* relay's preview HTTP routes (`GET /native/projections/{operationId}`). It has
+* no stability guarantee and no production qualification: real iOS, Apple
+* provisioning, Secure Enclave, and hosted operations are later work.
+*
+* What it owns: turning one stored authorization request into the projection
+* the owner's phone renders before deciding. It owns nothing about deciding;
+* the relay's decision use case stays the only decision owner.
+*
+* Two very different surfaces share this file, and only one of them is opaque:
+*
+* - The **push** projection (`operationId`, `displayPayload`, `expiresAt`)
+*   transits Apple inside an APNs payload, so it stays opaque by design: no
+*   permission, scope, client, chain, or account detail may ride it. The APNs
+*   sender enforces that subset exactly.
+* - The **consent** projection returned here travels only the authenticated
+*   relay → owner channel, so it deliberately carries the full authorization
+*   request: the requesting client identity and the requested scope. The owner
+*   must see exactly the authority they grant before approving.
+*
+* `displayPayload` is not a secret and not authority: it is a deterministic
+* digest of the request and its bound subject, so the owner can check that the
+* code on the phone is the code the browser shows. Holding it authorizes
+* nothing — deciding still requires the authenticated bound owner.
+*
+* @author taek <leekt216@gmail.com>
+*/
+/** Versioned consent envelope; the Swift decoder pins this exact value. */
+const OAATH_NATIVE_PROJECTION_VERSION = "oaath.native-projection/v7";
+/**
+* The stored scope is the requesting client's own JSON permission scope (the
+* SDK serializes a permission request without its `requestId`; the relay's
+* request id is the binding). An unparseable scope is not a failure: the owner
+* still gets the raw text to review, never a silent omission.
+*/
+function projectCredential(credential) {
+	if (credential.kind === "ecdsa") return Object.freeze({
+		kind: "ecdsa",
+		address: credential.address ?? ""
+	});
+	if (credential.kind === "p256") return Object.freeze({
+		kind: "p256",
+		publicKey: credential.publicKey ?? ""
+	});
+	return Object.freeze({
+		kind: "webauthn",
+		publicKey: credential.publicKey ?? "",
+		authenticatorIdHash: credential.authenticatorIdHash ?? ""
+	});
+}
+/** One owner for permission display facts in both grant and removal consent. */
+async function projectPermissionConsent(request) {
+	if (isKernelExistingAccountProfile(request.logicalAccount)) return relayFailure("relay_request_invalid", "phone consent requires a Kernel v4 account");
+	return Object.freeze({
+		kind: "permission-request",
+		decision: "approve-or-reject",
+		context: request.context,
+		application: Object.freeze({
+			applicationId: request.application.applicationId,
+			clientId: request.application.clientId,
+			origin: request.application.origin,
+			deviceFingerprint: (await sha256Base64Url(`${NATIVE_DISPLAY_DOMAIN}device:${request.application.deviceId}`)).slice(0, 8)
+		}),
+		account: Object.freeze({
+			accountIndex: request.logicalAccount.accountIndex,
+			kernelVersion: request.logicalAccount.kernelVersion,
+			factoryRoute: request.logicalAccount.factoryRoute,
+			entryPointVersion: request.logicalAccount.entryPoint.version,
+			ownerCredential: projectCredential(request.logicalAccount.ownerCredential)
+		}),
+		operatorCredential: projectCredential(request.operatorCredential),
+		sessionSigner: request.sessionSigner === null ? null : Object.freeze({
+			mode: request.sessionSigner.mode,
+			providerId: request.sessionSigner.providerId
+		}),
+		chainScope: request.chainScope,
+		calls: Object.freeze(request.policy.calls.map((call) => Object.freeze({
+			target: call.target,
+			selector: call.selector,
+			valueLimit: call.valueLimit,
+			argumentEquals: Object.freeze(call.argumentEquals.map((rule) => Object.freeze({
+				index: rule.index,
+				value: rule.value
+			})))
+		}))),
+		requestedAt: request.requestedAt,
+		expiresAt: request.expiresAt,
+		policyValidAfter: request.policy.validAfter,
+		policyValidUntil: request.policy.validUntil,
+		perChainOperationLimit: request.policy.perChainOperationLimit.count,
+		perChainOperationIntervalSeconds: request.policy.perChainOperationLimit.intervalSeconds
+	});
+}
+async function projectOwnerPhoneScope(requestedScope, operationId) {
+	try {
+		const classified = classifyStoredAuthorizationScope(requestedScope, operationId);
+		if (classified.kind === "permission-request") return projectPermissionConsent(classified.request);
+		if (classified.kind === "kernel-owner-signing-request") return Object.freeze({
+			kind: "owner-signing-request",
+			decision: "approve-or-reject",
+			requestHash: hashOwnerSigningRequest(classified.request),
+			request: classified.request
+		});
+		if (classified.kind === "owner-signing-request") return Object.freeze({
+			kind: "owner-signing-request",
+			decision: "reject-only",
+			requestHash: hashOwnerSigningRequest(classified.request),
+			request: classified.request
+		});
+		return Object.freeze({
+			kind: "raw",
+			decision: "reject-only",
+			text: requestedScope
+		});
+	} catch {
+		return Object.freeze({
+			kind: "raw",
+			decision: "reject-only",
+			text: requestedScope
+		});
+	}
+}
+/**
+* Projects a pending request for its bound owner. An expired or already decided
+* request is not projectable: there is nothing left to approve, so nothing is
+* ever pushed or rendered for it.
+*/
+async function pendingOwnerRequest(input) {
+	if (input.caller.role !== "owner") return relayFailure("relay_forbidden", "caller may not act in the required role");
+	const state = await fetchAuthorizationRequest({
+		store: input.store,
+		clock: input.clock,
+		caller: input.caller,
+		requestId: input.requestId
+	});
+	if (state.expired) return relayFailure("relay_expired", "authorization request expired");
+	if (state.decision !== null) return relayFailure("relay_already_decided", "authorization request is already decided");
+	return state;
+}
+async function projectionFromState(state, caller, scope) {
+	return Object.freeze({
+		version: OAATH_NATIVE_PROJECTION_VERSION,
+		operationId: state.requestId,
+		displayPayload: await ownerPhoneDisplayPayload(caller.subject, state.requestId),
+		expiresAt: state.expiresAt,
+		client: Object.freeze({
+			clientId: state.clientId,
+			redirectUri: state.redirectUri
+		}),
+		scope
+	});
+}
+async function projectOwnerPhoneRequest(input) {
+	const state = await pendingOwnerRequest(input);
+	return projectionFromState(state, input.caller, await projectOwnerPhoneScope(state.requestedScope, state.requestId));
+}
+/** The signing packet for the same consent, using the existing projection wire shape. */
+async function projectOwnerPhonePermissionSigning(input) {
+	const state = await pendingOwnerRequest(input);
+	const scope = classifyStoredAuthorizationScope(state.requestedScope, state.requestId);
+	if (scope.kind !== "permission-request") return relayFailure("relay_request_invalid", "request is not a permission");
+	const prepared = await prepareOwnerPhonePermissionApproval(input.permissionApprovals, scope.request);
+	return projectionFromState(state, input.caller, Object.freeze({
+		kind: "owner-signing-request",
+		decision: "approve-or-reject",
+		requestHash: hashOwnerSigningRequest(prepared.signingRequest),
+		request: prepared.signingRequest
+	}));
+}
+//#endregion
+//#region src/native/revocation.ts
+/** Consent projection for an immutable owner revocation request; no admission or decision state. */
+/**
+* Projects a stored request for its authenticated owner. The calling queue owns
+* admission, current ownership, expiry and terminal-decision checks; this helper
+* owns only consent bytes. It performs no signing, submission or observation.
+*/
+async function projectOwnerPhoneRevocation(input) {
+	if (!/^[A-Za-z0-9._~-]{1,64}$/u.test(input.operationId) || !input.ownerSubject || !Number.isSafeInteger(input.expiresAt) || input.expiresAt < 0) return relayFailure("relay_request_invalid", "revocation projection metadata is invalid");
+	const request = parseKernelRevocationSigningRequest(input.request);
+	return Object.freeze({
+		version: OAATH_NATIVE_PROJECTION_VERSION,
+		operationId: input.operationId,
+		displayPayload: await ownerPhoneDisplayPayload(input.ownerSubject, input.operationId),
+		expiresAt: input.expiresAt,
+		client: Object.freeze({
+			clientId: request.permissionRequest.application.clientId,
+			redirectUri: null
+		}),
+		scope: Object.freeze({
+			kind: "kernel-revocation",
+			decision: "approve-or-reject",
+			requestHash: hashKernelRevocationSigningRequest(request),
+			permission: await projectPermissionConsent(request.permissionRequest),
+			install: Object.freeze({
+				kind: "owner-signing-request",
+				decision: "approve-or-reject",
+				requestHash: hashOwnerSigningRequest(request.install),
+				request: request.install
+			}),
+			effect: request.effect,
+			chainId: request.chainId,
+			entryPoint: request.entryPoint,
+			operation: request.operation,
+			expectedDigest: request.expectedDigest
+		})
+	});
+}
+//#endregion
+//#region src/revocation/service.ts
+/**
+* Owner revocation custody: absent -> pending -> approved | rejected once.
+* The immutable request and terminal decision are the only persisted evidence.
+* Approval occupies this operation ID; it proves custody, never submission or
+* onchain completion. No execution lane is acquired here. A decision retry reads
+* the stored outcome before expiry or artifact handling. An ambiguous enqueue
+* response is recovered by looking up the original grant/chain; it never
+* authorizes a blind insertion. Only expired undecided custody may be replaced.
+* Enqueue recovery needs only the store; signing custody needs KMS. There
+* is no in-memory preparation to recover. Transactions own rollback and release.
+*/
+async function readClientState(transaction, input) {
+	if (input.caller.role !== "client") return relayFailure("relay_forbidden", "only the originating client may request revocation");
+	const source = await transaction.lockAuthorizationRequest(input.grantId);
+	if (!source || source.clientId !== input.caller.clientId || source.subject !== input.caller.subject) return relayFailure("relay_forbidden", "permission is not owned by this caller");
+	const request = await transaction.lockLatestRevocationRequest(input.grantId, input.chainId);
+	return {
+		source,
+		current: request ? {
+			request,
+			decision: await readDecision(transaction, request)
+		} : null
+	};
+}
+function statusOf(state, clock) {
+	return Object.freeze({
+		grantId: state.request.signingRequest.permissionRequest.requestId,
+		chainId: state.request.signingRequest.chainId,
+		operationId: state.request.operationId,
+		expiresAt: state.request.expiresAt,
+		status: state.decision?.outcome ?? (relayNow(clock) > state.request.expiresAt ? "expired" : "pending")
+	});
+}
+function reusable(state, clock) {
+	return state !== null && (state.decision !== void 0 || relayNow(clock) <= state.request.expiresAt);
+}
+/** Authenticated metadata lookup. It never prepares, opens KMS custody or submits. */
+async function fetchClientPhoneRevocation(input) {
+	return withRelayTransaction(input.store, async (transaction) => {
+		const { current } = await readClientState(transaction, input);
+		if (!current) return relayFailure("relay_not_found", "revocation request is absent");
+		return statusOf(current, input.clock);
+	});
+}
+/**
+* Returns the current grant/chain request before touching preparation or KMS.
+* Only positively expired, undecided custody may be replaced. Approved custody
+* remains immutable even after expiry: operation evidence owns any replacement.
+* Pure preparation runs outside the transaction; final admission locks the
+* original grant again so concurrent callers share the winner's exact request.
+*/
+async function requestOwnerPhoneRevocation(input) {
+	const { store, clock, kms, directory, caller, grantId, chainId, requestTtlMs, prepare } = input;
+	if (!Number.isSafeInteger(chainId) || chainId < 1 || !Number.isSafeInteger(requestTtlMs) || requestTtlMs < 1) return relayFailure("relay_request_invalid", "revocation chain or TTL is invalid");
+	const source = await withRelayTransaction(store, async (transaction) => {
+		const { source: request, current } = await readClientState(transaction, input);
+		if (current && reusable(current, clock)) return { retained: statusOf(current, clock) };
+		const scope = classifyStoredAuthorizationScope(request.requestedScope, request.requestId);
+		const decision = await transaction.lockAuthorizationDecision(grantId);
+		if (scope.kind !== "permission-request" || decision?.outcome !== "approved") return relayFailure("relay_request_invalid", "permission is not approved");
+		const owner = await directory.resolveRevocationOwner(caller, {
+			requestId: grantId,
+			requestedScope: request.requestedScope,
+			chainId
+		});
+		if (!owner) return relayFailure("relay_forbidden", "account or chain is not assigned");
+		const retained = await readApprovedPermission(transaction, kms, request, decision, scope.request);
+		if (!retained) return relayFailure("relay_record_unreadable", "approved permission is unreadable");
+		return {
+			request: scope.request,
+			artifact: retained.plaintext,
+			owner
+		};
+	});
+	if ("retained" in source) return Object.freeze({
+		...source.retained,
+		created: false
+	});
+	let signingRequest;
+	try {
+		signingRequest = parseKernelRevocationSigningRequest(await prepare(Object.freeze({
+			request: source.request,
+			artifact: source.artifact,
+			chainId
+		})));
+	} catch {
+		return relayFailure("relay_request_invalid", "revocation preparation failed");
+	}
+	if (signingRequest.chainId !== chainId || hashPermissionRequest(signingRequest.permissionRequest) !== hashPermissionRequest(source.request)) return relayFailure("relay_request_invalid", "prepared revocation changed its permission or chain");
+	return withRelayTransaction(store, async (transaction) => {
+		const { current } = await readClientState(transaction, input);
+		if (current && reusable(current, clock)) return Object.freeze({
+			...statusOf(current, clock),
+			created: false
+		});
+		const createdAt = relayNow(clock);
+		const expiresAt = timestamp(createdAt + requestTtlMs, "revocation expiry", "relay_request_invalid");
+		const record = Object.freeze({
+			version: OAATH_REVOCATION_REQUEST_RECORD_VERSION,
+			operationId: REVOCATION_OPERATION_PREFIX + randomIdentifier(),
+			...source.owner,
+			createdAt,
+			expiresAt,
+			signingRequest
+		});
+		if (!await transaction.insertRevocationRequest(record)) return relayFailure("relay_state_ambiguous", "revocation request insertion did not settle");
+		return Object.freeze({
+			...statusOf({
+				request: record,
+				decision: void 0
+			}, clock),
+			created: true
+		});
+	});
+}
+async function readOwnerState(transaction, input) {
+	if (input.caller.role !== "owner") return relayFailure("relay_forbidden", "caller may not decide");
+	const state = await readRevocationState(transaction, input.operationId);
+	if (state.request.ownerSubject !== input.caller.subject) return relayFailure("relay_forbidden", "revocation belongs to another owner");
+	return state;
+}
+/** Shared durable request/decision binding; caller admission belongs to each use case. */
+async function readRevocationState(transaction, operationId) {
+	const request = await transaction.lockRevocationRequest(operationId);
+	if (!request) return relayFailure("relay_not_found", "revocation request is absent");
+	return {
+		request,
+		decision: await readDecision(transaction, request)
+	};
+}
+async function readDecision(transaction, request) {
+	const decision = await transaction.lockRevocationDecision(request.operationId);
+	if (decision && (decision.decidedAt < request.createdAt || decision.decidedAt > request.expiresAt)) return relayFailure("relay_record_unreadable", "revocation decision time contradicts its request");
+	return decision;
+}
+function requirePending(request, clock) {
+	if (relayNow(clock) > request.expiresAt) return relayFailure("relay_expired", "revocation request expired");
+}
+async function fetchOwnerPhoneRevocation(input) {
+	const { request, decision } = await withRelayTransaction(input.store, (transaction) => readOwnerState(transaction, input));
+	if (decision) return relayFailure("relay_already_decided", "revocation is already decided");
+	requirePending(request, input.clock);
+	return projectOwnerPhoneRevocation({
+		operationId: request.operationId,
+		ownerSubject: request.ownerSubject,
+		expiresAt: request.expiresAt,
+		request: request.signingRequest
+	});
+}
+function answer(decision, settlement) {
+	return Object.freeze({
+		version: "oaath.native-revocation-decision/v1",
+		operationId: decision.operationId,
+		outcome: decision.outcome,
+		decidedAt: decision.decidedAt,
+		settlement
+	});
+}
+async function submitOwnerPhoneRevocationDecision(input) {
+	const initial = await withRelayTransaction(input.store, (transaction) => readOwnerState(transaction, input));
+	if (initial.decision) return answer(initial.decision, "replayed");
+	requirePending(initial.request, input.clock);
+	const artifactRef = input.command.outcome === "approved" ? await sealArtifact(input.kms, verifyKernelV4RevocationOwnerSigningArtifact(initial.request.signingRequest, input.command.artifact)) : null;
+	return withRelayTransaction(input.store, async (transaction) => {
+		const { request, decision } = await readOwnerState(transaction, input);
+		if (decision) return answer(decision, "replayed");
+		requirePending(request, input.clock);
+		const decidedAt = relayNow(input.clock);
+		if (decidedAt < request.createdAt || decidedAt > request.expiresAt) return relayFailure("relay_expired", "decision is outside the request window");
+		const record = Object.freeze({
+			version: OAATH_REVOCATION_DECISION_RECORD_VERSION,
+			operationId: request.operationId,
+			outcome: input.command.outcome,
+			decidedAt,
+			artifactRef
+		});
+		if (!await transaction.insertRevocationDecision(record)) return relayFailure("relay_state_ambiguous", "revocation decision insertion did not settle");
+		return answer(record, "decided");
+	});
+}
+//#endregion
+export { withRelayTransaction as S, verifyKernelV4ReplayableInstallOwnerSigningArtifact as _, submitOwnerPhoneRevocationDecision as a, openArtifact as b, projectOwnerPhonePermissionSigning as c, classifyStoredAuthorizationScope as d, createAuthorizationRequest as f, ownerPhoneDisplayPayload as g, NATIVE_DISPLAY_PAYLOAD_LENGTH as h, requestOwnerPhoneRevocation as i, projectOwnerPhoneRequest as l, readAuthorizationState as m, fetchOwnerPhoneRevocation as n, projectOwnerPhoneRevocation as o, fetchAuthorizationRequest as p, readRevocationState as r, OAATH_NATIVE_PROJECTION_VERSION as s, fetchClientPhoneRevocation as t, prepareOwnerPhonePermissionApproval as u, parseApprovedPermission as v, sealArtifact as x, readApprovedPermission as y };
+
+//# sourceMappingURL=service-Cf4f-9KP.js.map