@oaath/server 0.1.0

package/dist/index.js

@@ -0,0 +1,1135 @@
+import { _ as jsonResponse, a as OAATH_ENCRYPTED_ARTIFACT_RECORD_VERSION, b as relayFailure, c as canonicalIdentifier, d as parseAuthorizationRequestRecord, f as parseCapabilityInvalidationRecord, g as RELAY_ERROR_STATUS, h as OaathRelayError, i as OAATH_CAPABILITY_INVALIDATION_RECORD_VERSION, l as parseAuthorizationCodeRecord, m as timestamp, n as OAATH_AUTHORIZATION_DECISION_RECORD_VERSION, o as RELAY_LIMITS, p as parseEncryptedArtifactRecord, r as OAATH_AUTHORIZATION_REQUEST_RECORD_VERSION, s as boundedText, t as OAATH_AUTHORIZATION_CODE_RECORD_VERSION, u as parseAuthorizationDecisionRecord, v as relayErrorCode, y as relayErrorResponse } from "./records-Bgr-9PUh.js";
+import { a as relayNow, i as verifyPkceS256, r as sha256Base64Url, t as isCodeChallengeS256 } from "./challenge-AGTmUfj2.js";
+import { a as submitAuthorizationDecision, c as readAuthorizationState, d as withRelayTransaction, i as submitOwnerPhoneDecision, l as openArtifact, o as createAuthorizationRequest, r as projectOwnerPhoneRequest, s as fetchAuthorizationRequest, u as sealArtifact } from "./projection-dGIkE0rI.js";
+import { OAATH_OPERATOR_CREDENTIAL_PROFILE_VERSION, OAATH_SERVICE_BOOTSTRAP_VERSION, captureDenseArray, captureRecord, exactCapturedRecord, exactRecord, parseServiceBootstrap } from "@oaath/protocol";
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils.js";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { keccak_256 } from "@noble/hashes/sha3.js";
+//#region src/artifact/claim.ts
+/**
+* One-time encrypted artifact release.
+*
+* ```text
+* state and owner        the artifact record's `claimedAt` owns "released"
+* transitions            sealed -> claimed, exactly once
+* terminal               claimed; a second claim fails closed
+* retry positively safe? no. The claim commits before the KMS is asked to
+*                        decrypt, so a decrypt or transport failure burns the
+*                        artifact instead of risking a second release
+* crash/reload           a crash before commit leaves the artifact claimable
+* ```
+*
+* @author taek <leekt216@gmail.com>
+*/
+async function claimEncryptedArtifact(input) {
+	const claimedAt = relayNow(input.clock);
+	const claimed = await withRelayTransaction(input.store, async (transaction) => {
+		const record = await transaction.lockEncryptedArtifact(input.artifactId);
+		if (!record || record.clientId !== input.caller.clientId) return relayFailure("relay_not_found", "encrypted artifact does not exist");
+		if (record.claimedAt !== null) relayFailure("relay_artifact_already_claimed", "encrypted artifact was already claimed");
+		if (!await transaction.claimEncryptedArtifact(input.artifactId, claimedAt)) relayFailure("relay_state_ambiguous", "one-time claim did not apply under its row lock");
+		return record;
+	});
+	return Object.freeze({
+		requestId: claimed.requestId,
+		artifact: await openArtifact(input.kms, claimed.ciphertextRef)
+	});
+}
+//#endregion
+//#region src/authorization/code.ts
+/**
+* One-time authorization code consume.
+*
+* ```text
+* state and owner        the code record's `consumedAt` owns "used"
+* transitions            issued -> consumed, exactly once
+* terminal               consumed; a second consume fails closed
+* retry positively safe? no, in either direction: a released code is never
+*                        re-released, and an ambiguous commit is never retried
+* crash/reload           the guarded update and the release decide together in one
+*                        transaction under the code's row lock
+* ```
+*
+* A failed PKCE or redirect binding still burns the code, so a stolen code
+* cannot be brute-forced against the stored challenge.
+*
+* The endpoint is not an oracle for whether a guessed code was correct: an
+* unknown code, a code bound to another client, a wrong redirect URI, and a
+* wrong verifier all leave as the single `relay_code_invalid` code and status.
+*
+* @author taek <leekt216@gmail.com>
+*/
+async function consumeAuthorizationCode(input) {
+	const consumedAt = relayNow(input.clock);
+	const codeHash = await sha256Base64Url(input.code);
+	const transaction = await input.store.begin();
+	let outcome;
+	try {
+		const record = await transaction.lockAuthorizationCode(codeHash);
+		if (!record || record.clientId !== input.caller.clientId) relayFailure("relay_code_invalid", "authorization code redemption failed");
+		if (record.consumedAt !== null) relayFailure("relay_code_already_consumed", "authorization code was already consumed");
+		if (consumedAt >= record.expiresAt) relayFailure("relay_expired", "authorization code expired");
+		const bound = record.redirectUri === input.redirectUri && await verifyPkceS256(input.codeVerifier, record.codeChallenge);
+		if (!await transaction.consumeAuthorizationCode(codeHash, consumedAt)) relayFailure("relay_state_ambiguous", "one-time consume did not apply under its row lock");
+		if (!bound) {
+			await transaction.lockEncryptedArtifact(record.artifactId);
+			await transaction.claimEncryptedArtifact(record.artifactId, consumedAt);
+		}
+		outcome = bound ? Object.freeze({
+			kind: "released",
+			released: Object.freeze({
+				requestId: record.requestId,
+				artifactId: record.artifactId
+			})
+		}) : Object.freeze({
+			kind: "burned",
+			code: "relay_code_invalid"
+		});
+	} catch (error) {
+		await transaction.rollback();
+		throw error;
+	}
+	await transaction.commit();
+	if (outcome.kind === "burned") relayFailure(outcome.code, "authorization code redemption failed and the code was burned");
+	return outcome.released;
+}
+//#endregion
+//#region src/authorization/resume.ts
+/**
+* Resume: fresh authentication plus a grant recovery read.
+*
+* Resume never transitions anything and never re-releases a code or an artifact.
+* The caller re-authenticates on every call, and receives only enough state to
+* decide whether its own grant work is still valid.
+*
+* @author taek <leekt216@gmail.com>
+*/
+function resumeAuthorization(input) {
+	const now = relayNow(input.clock);
+	return withRelayTransaction(input.store, (transaction) => readAuthorizationState(transaction, input.requestId, now, (request) => request.clientId === input.caller.clientId));
+}
+//#endregion
+//#region src/authorization/pickup.ts
+/**
+* Authenticated client pickup of a released authorization code.
+*
+* ```text
+* state and owner        reads the request and decision records; writes nothing
+* transitions            none — pickup is idempotent
+* terminal               follows the decision record
+* retry positively safe? yes: the code stays one-shot at consumption, where the
+*                        PKCE verifier and the code hash lock decide
+* ```
+*
+* The relay mints the code, so releasing the sealed copy to the authenticated
+* creating client adds no authority: consumption still requires the verifier
+* only that client holds. The request's stored clientId owns who may pick up;
+* any other caller reads absence, never existence.
+*
+* @author taek <leekt216@gmail.com>
+*/
+async function fetchAuthorizationCode(input) {
+	const now = relayNow(input.clock);
+	const decided = await withRelayTransaction(input.store, async (transaction) => {
+		const request = await transaction.lockAuthorizationRequest(input.requestId);
+		if (!request || request.clientId !== input.caller.clientId) return relayFailure("relay_not_found", "authorization request does not exist");
+		const decision = await transaction.lockAuthorizationDecision(input.requestId);
+		if (!decision) {
+			if (now >= request.expiresAt) return relayFailure("relay_expired", "authorization request expired");
+			return null;
+		}
+		return decision;
+	});
+	if (decided === null) return Object.freeze({ outcome: "pending" });
+	if (decided.outcome === "rejected" || decided.codeRef === null) return Object.freeze({
+		outcome: "rejected",
+		decidedAt: decided.decidedAt
+	});
+	const codeExpiresAt = decided.codeExpiresAt ?? 0;
+	if (now >= codeExpiresAt) return relayFailure("relay_expired", "authorization code expired");
+	return Object.freeze({
+		outcome: "approved",
+		decidedAt: decided.decidedAt,
+		code: await openArtifact(input.kms, decided.codeRef),
+		codeExpiresAt
+	});
+}
+//#endregion
+//#region src/security/authentication.ts
+/**
+* Deployment-owned client/device authentication port.
+*
+* The relay never parses credentials. It hands the request to the deployment,
+* which returns the authenticated bindings or nothing. `clientId` and `subject`
+* come only from here: wire input may never declare either.
+*
+* @author taek <leekt216@gmail.com>
+*/
+const MAX_REDIRECT_URIS = 8;
+function captureCaller(value) {
+	const context = /* @__PURE__ */ new WeakSet();
+	const fail = (message) => relayFailure("relay_internal", message);
+	const record = exactRecord(value, [
+		"role",
+		"clientId",
+		"subject",
+		"redirectUris"
+	], "authenticated caller", context, fail);
+	if (record.role !== "client" && record.role !== "owner") return relayFailure("relay_internal", "authenticated caller role is unsupported");
+	const redirectUris = captureDenseArray(record.redirectUris, "caller redirectUris", context, fail);
+	if (redirectUris.length > MAX_REDIRECT_URIS) return relayFailure("relay_internal", "caller redirectUris is unbounded");
+	return Object.freeze({
+		role: record.role,
+		clientId: canonicalIdentifier(record.clientId, "caller clientId", "relay_internal"),
+		subject: canonicalIdentifier(record.subject, "caller subject", "relay_internal"),
+		redirectUris: Object.freeze(redirectUris.map((uri) => boundedText(uri, RELAY_LIMITS.redirectUri, "caller redirectUri", "relay_internal")))
+	});
+}
+async function authenticateCaller(authentication, request, required) {
+	let authenticated;
+	try {
+		authenticated = await authentication.authenticate(request);
+	} catch (error) {
+		if (error instanceof OaathRelayError) throw error;
+		return relayFailure("relay_unauthenticated", "authentication port failed");
+	}
+	if (authenticated === null || authenticated === void 0) return relayFailure("relay_unauthenticated", "caller is not authenticated");
+	const caller = captureCaller(authenticated);
+	if (!(typeof required === "string" ? [required] : required).includes(caller.role)) return relayFailure("relay_forbidden", "caller may not act in the required role");
+	return caller;
+}
+//#endregion
+//#region src/security/rate-limit.ts
+/**
+* Optional deployment-owned limiter port.
+*
+* There is no default limiter: an unset port means no limiting, and the relay
+* never invents a policy the deployment did not choose. A limiter that fails is
+* treated as `limited`, because an unreadable limiter is not permission.
+*
+* @author taek <leekt216@gmail.com>
+*/
+async function assertWithinRateLimit(limiter, input) {
+	if (!limiter) return;
+	let verdict;
+	try {
+		verdict = await limiter.check(input);
+	} catch {
+		return relayFailure("relay_rate_limited", "rate limiter is unreadable");
+	}
+	if (verdict !== "allowed") return relayFailure("relay_rate_limited", "rate limiter rejected the call");
+}
+//#endregion
+//#region src/relay/handler.ts
+/**
+* Fetch-standard relay handler.
+*
+* Every wire input is exact-captured once here and handed to a use case as typed
+* data. Every failure leaves as a structured code projected to a status; no
+* message text, driver output, or internal detail reaches a response body.
+*
+* Endpoints:
+*
+* ```text
+* POST /authorization/requests                       client  create request
+* GET  /authorization/requests/{requestId}           owner   fetch request
+* POST /authorization/requests/{requestId}/decision  owner   approve or reject
+* GET  /authorization/requests/{requestId}/code      client  released-code pickup
+* POST /authorization/codes/consume                  client  one-time code consume
+* POST /authorization/artifacts/{artifactId}/claim   client  one-time artifact claim
+* POST /authorization/resume                         client  fresh auth + recovery read
+* GET  /bootstrap                                    client  URL-only service context
+* POST /invalidations                                client  capability invalidation
+* POST /chains/{chainId}/{port}                      client  chain execution relay,
+*                                                            port in reads |
+*                                                            observation | bundler |
+*                                                            quote | submissions | usage
+* POST /chains/{chainId}/paymaster/{method}           client  registered paymaster proxy,
+*                                                            method in stub-data | data
+* ```
+*
+* EXPERIMENTAL PREVIEW routes for the owner-phone approval surface. Preview
+* means: no stability guarantee and no production qualification. Their wire
+* shapes are pinned field-for-field by the strict Swift decoders in
+* `native/ios/Sources/OwnerPhone/{Projection,Decision}.swift`.
+*
+* ```text
+* GET  /native/projections/{operationId}             owner   consent projection
+* POST /native/decisions/{operationId}               owner   approve or reject saga
+* ```
+*
+* @author taek <leekt216@gmail.com>
+*/
+const DEFAULT_REQUEST_TTL_MS = 3e5;
+const DEFAULT_CODE_TTL_MS = 6e4;
+const DEFAULT_MAX_BODY_BYTES = 65536;
+const MAX_TTL_MS = 864e5;
+/** RFC 6749 ceiling, matching `MAX_AUTHORIZATION_CODE_LIFETIME` in @oaath/protocol. */
+const MAX_CODE_TTL_MS = 6e5;
+const MAX_PAYMASTER_REQUEST_TIMEOUT_MS = 3e4;
+const HASH$1 = /^0x[0-9a-f]{64}$/u;
+const INVALID = "relay_request_invalid";
+const OPTION_KEYS = [
+	"store",
+	"authentication",
+	"kms",
+	"clock",
+	"rateLimit",
+	"requestTtlMs",
+	"codeTtlMs",
+	"maxBodyBytes",
+	"bootstrap",
+	"chains",
+	"sessionSigner",
+	"paymasterServices"
+];
+const CHAIN_PORT_NAMES = [
+	"reads",
+	"observation",
+	"bundler",
+	"quote",
+	"submission"
+];
+/**
+* The Grant a chain port request acts for, where the port's contract names
+* one: a submission's prepared operation and a usage read both carry it.
+* Reading it here is bounded extraction for the invalidation gate, not
+* interpretation — the port's own owner still captures the payload exactly.
+*/
+function chainRequestGrantId(name, request) {
+	try {
+		if (name === "usage") {
+			const grantId = request?.grantId;
+			return typeof grantId === "string" && grantId.length > 0 ? grantId : null;
+		}
+		if (name === "submission") {
+			const grantId = (request?.prepared)?.grantId;
+			return typeof grantId === "string" && grantId.length > 0 ? grantId : null;
+		}
+	} catch {}
+	return null;
+}
+/**
+* Ports may be class instances, so only their required capabilities are checked.
+* Narrowing follows the runtime check.
+*/
+function requirePort(value, methods, label) {
+	if (!value || typeof value !== "object") return relayFailure("relay_internal", `${label} must be an object`);
+	for (const method of methods) if (typeof value[method] !== "function") return relayFailure("relay_internal", `${label} must implement ${method}()`);
+	return value;
+}
+function duration(value, fallback, label, maximum = MAX_TTL_MS) {
+	if (value === void 0) return fallback;
+	const milliseconds = timestamp(value, label, "relay_internal");
+	if (milliseconds < 1 || milliseconds > maximum) return relayFailure("relay_internal", `${label} must be a bounded positive duration`);
+	return milliseconds;
+}
+function captureChainPorts(value) {
+	if (!Array.isArray(value)) return relayFailure("relay_internal", "chains must be an array of chain ports");
+	const chains = /* @__PURE__ */ new Map();
+	for (const entry of value) {
+		const port = requirePort(entry, [...CHAIN_PORT_NAMES], "chain port");
+		if (typeof port.chainId !== "number" || !Number.isSafeInteger(port.chainId) || port.chainId < 1) return relayFailure("relay_internal", "chain port chainId must be a positive integer");
+		if (port.usage !== null && typeof port.usage !== "function") return relayFailure("relay_internal", "chain port usage must be a function or null");
+		if (port.staticPaymasterConfigurationHash !== null && (typeof port.staticPaymasterConfigurationHash !== "string" || !HASH$1.test(port.staticPaymasterConfigurationHash))) return relayFailure("relay_internal", "chain port static paymaster commitment must be a lowercase hash or null");
+		if (chains.has(port.chainId)) return relayFailure("relay_internal", "chain ports repeat a chainId");
+		chains.set(port.chainId, port);
+	}
+	return chains;
+}
+function capturePaymasterServices(value, context, chains) {
+	if (value === void 0) return /* @__PURE__ */ new Map();
+	const entries = captureDenseArray(value, "paymaster services", context, (message) => relayFailure("relay_internal", message));
+	const services = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const service = exactCapturedRecord(captureRecord(entry, "paymaster service", context, (message) => relayFailure("relay_internal", message)), [
+			"chainId",
+			"providerId",
+			"requestTimeoutMs",
+			"provider"
+		], "paymaster service", (message) => relayFailure("relay_internal", message));
+		const chainId = service.chainId;
+		if (typeof chainId !== "number" || !Number.isSafeInteger(chainId) || chainId < 1) relayFailure("relay_internal", "paymaster service chainId must be a positive integer");
+		if (!chains.has(chainId)) relayFailure("relay_internal", "paymaster service chain is not configured");
+		if (services.has(chainId)) relayFailure("relay_internal", "paymaster services repeat a chainId");
+		if (service.requestTimeoutMs === void 0) relayFailure("relay_internal", "paymaster requestTimeoutMs is required");
+		services.set(chainId, Object.freeze({
+			chainId,
+			providerId: canonicalIdentifier(service.providerId, "paymaster providerId", "relay_internal"),
+			requestTimeoutMs: duration(service.requestTimeoutMs, 0, "paymaster requestTimeoutMs", MAX_PAYMASTER_REQUEST_TIMEOUT_MS),
+			provider: requirePort(service.provider, ["getPaymasterStubData", "getPaymasterData"], "paymaster provider")
+		}));
+	}
+	return services;
+}
+function captureOptions(value) {
+	const context = /* @__PURE__ */ new WeakSet();
+	const record = captureRecord(value, "relay handler options", context, (message) => relayFailure("relay_internal", message));
+	for (const key of Object.keys(record)) if (!OPTION_KEYS.includes(key)) relayFailure("relay_internal", "relay handler options contain an unknown field");
+	const chains = record.chains === void 0 ? /* @__PURE__ */ new Map() : captureChainPorts(record.chains);
+	const rateLimit = record.rateLimit === void 0 ? void 0 : requirePort(record.rateLimit, ["check"], "rateLimit");
+	const paymasterServices = capturePaymasterServices(record.paymasterServices, context, chains);
+	if (paymasterServices.size > 0) {
+		if (record.bootstrap === void 0) relayFailure("relay_internal", "a paymaster service requires a bootstrap surface");
+		if (rateLimit === void 0) relayFailure("relay_internal", "a paymaster service requires a rate limiter");
+	}
+	let sessionSigner = null;
+	if (record.sessionSigner !== void 0) {
+		if (record.bootstrap === void 0) relayFailure("relay_internal", "a session signer requires a bootstrap surface");
+		const custody = captureRecord(record.sessionSigner, "relay session signer configuration", context, (message) => relayFailure("relay_internal", message));
+		if (custody.mode !== "application_backend" && custody.mode !== "oaath_hosted") relayFailure("relay_internal", "session signer mode is unsupported");
+		if (typeof custody.providerId !== "string" || custody.providerId.length < 1) relayFailure("relay_internal", "session signer providerId is invalid");
+		sessionSigner = Object.freeze({
+			mode: custody.mode,
+			providerId: custody.providerId,
+			provider: requirePort(custody.provider, ["credential", "sign"], "session signer provider")
+		});
+	}
+	let bootstrap = null;
+	if (record.bootstrap !== void 0) {
+		if (chains.size === 0) relayFailure("relay_internal", "a bootstrap surface requires chain ports");
+		const identity = captureRecord(record.bootstrap, "relay bootstrap configuration", context, (message) => relayFailure("relay_internal", message));
+		try {
+			bootstrap = parseServiceBootstrap({
+				version: OAATH_SERVICE_BOOTSTRAP_VERSION,
+				application: identity.application,
+				userHandle: identity.userHandle,
+				account: identity.account,
+				ownerValidator: identity.ownerValidator,
+				chains: [...chains.values()].map((port) => {
+					const paymasterService = paymasterServices.get(port.chainId);
+					return {
+						chainId: port.chainId,
+						usage: port.usage !== null,
+						feePayer: port.feePayer,
+						paymasterService: paymasterService === void 0 ? null : { providerId: paymasterService.providerId },
+						staticPaymasterConfigurationHash: port.staticPaymasterConfigurationHash
+					};
+				}),
+				sessionSigner: sessionSigner === null ? {
+					mode: "frontend",
+					providerId: null
+				} : {
+					mode: sessionSigner.mode,
+					providerId: sessionSigner.providerId
+				}
+			});
+		} catch {
+			relayFailure("relay_internal", "relay bootstrap configuration is invalid");
+		}
+	}
+	return Object.freeze({
+		store: requirePort(record.store, ["begin", "close"], "store"),
+		authentication: requirePort(record.authentication, ["authenticate"], "authentication"),
+		kms: requirePort(record.kms, ["encrypt", "decrypt"], "kms"),
+		clock: requirePort(record.clock, ["now"], "clock"),
+		rateLimit,
+		requestTtlMs: duration(record.requestTtlMs, DEFAULT_REQUEST_TTL_MS, "requestTtlMs"),
+		codeTtlMs: duration(record.codeTtlMs, DEFAULT_CODE_TTL_MS, "codeTtlMs", MAX_CODE_TTL_MS),
+		maxBodyBytes: duration(record.maxBodyBytes, DEFAULT_MAX_BODY_BYTES, "maxBodyBytes"),
+		bootstrap,
+		sessionSigner,
+		chains,
+		paymasterServices
+	});
+}
+function requireMethod(request, expected) {
+	if (request.method !== expected) relayFailure("relay_method_not_allowed", "route does not accept this method");
+}
+async function bodyRecord(request, maxBodyBytes) {
+	if (!(request.headers.get("content-type") ?? "").toLowerCase().startsWith("application/json")) relayFailure(INVALID, "request body must be application/json");
+	let text;
+	try {
+		text = await request.text();
+	} catch {
+		return relayFailure(INVALID, "request body is unreadable");
+	}
+	if (new TextEncoder().encode(text).byteLength > maxBodyBytes) return relayFailure(INVALID, "request body exceeds its bound");
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return relayFailure(INVALID, "request body is not JSON");
+	}
+	return captureRecord(parsed, "request body", /* @__PURE__ */ new WeakSet(), (message) => relayFailure(INVALID, message));
+}
+function exactBody(record, keys) {
+	return exactCapturedRecord(record, keys, "request body", (message) => relayFailure(INVALID, message));
+}
+async function invokePaymasterService(service, method, caller, params) {
+	const controller = new AbortController();
+	let timeout;
+	try {
+		const deadline = new Promise((_resolve, reject) => {
+			timeout = setTimeout(() => {
+				controller.abort();
+				reject(/* @__PURE__ */ new Error("paymaster request deadline elapsed"));
+			}, service.requestTimeoutMs);
+		});
+		const capability = method === "stub-data" ? service.provider.getPaymasterStubData : service.provider.getPaymasterData;
+		const request = Object.freeze({
+			caller: Object.freeze({
+				clientId: caller.clientId,
+				subject: caller.subject
+			}),
+			params,
+			signal: controller.signal
+		});
+		return await Promise.race([Promise.resolve(Reflect.apply(capability, void 0, [request])), deadline]);
+	} catch {
+		return relayFailure("relay_chain_unavailable", "paymaster provider did not answer");
+	} finally {
+		if (timeout !== void 0) clearTimeout(timeout);
+	}
+}
+function decisionCommand(record) {
+	if (record.outcome === "approved") {
+		const exact = exactBody(record, ["outcome", "artifact"]);
+		return Object.freeze({
+			outcome: "approved",
+			artifact: boundedText(exact.artifact, RELAY_LIMITS.artifactPlaintext, "artifact", INVALID)
+		});
+	}
+	if (record.outcome === "rejected") {
+		exactBody(record, ["outcome"]);
+		return Object.freeze({ outcome: "rejected" });
+	}
+	return relayFailure(INVALID, "decision outcome is unsupported");
+}
+/**
+* EXPERIMENTAL PREVIEW — the phone decision body: `{command, artifact?}`.
+* `approve` hands over the artifact the client will claim once; `reject`
+* carries nothing else. The saga answers the stored outcome on a replay.
+*/
+function phoneDecisionCommand(record) {
+	if (record.command === "approve") {
+		const exact = exactBody(record, ["command", "artifact"]);
+		return Object.freeze({
+			outcome: "approved",
+			artifact: boundedText(exact.artifact, RELAY_LIMITS.artifactPlaintext, "artifact", INVALID)
+		});
+	}
+	if (record.command === "reject") {
+		exactBody(record, ["command"]);
+		return Object.freeze({ outcome: "rejected" });
+	}
+	return relayFailure(INVALID, "decision command is unsupported");
+}
+function stateBody(state) {
+	return {
+		requestId: state.requestId,
+		clientId: state.clientId,
+		redirectUri: state.redirectUri,
+		requestedScope: state.requestedScope,
+		expiresAt: state.expiresAt,
+		expired: state.expired,
+		decision: state.decision
+	};
+}
+function createRelayHandler(options) {
+	const captured = captureOptions(options);
+	const authenticate = async (request, role, route) => {
+		const caller = await authenticateCaller(captured.authentication, request, role);
+		await assertWithinRateLimit(captured.rateLimit, {
+			route,
+			clientId: caller.clientId
+		});
+		return caller;
+	};
+	const route = async (request) => {
+		const segments = new URL(request.url).pathname.split("/").filter((part) => part.length > 0);
+		const [head, group, third, fourth] = segments;
+		if (head === "native") {
+			if (segments.length === 3 && group === "projections") {
+				requireMethod(request, "GET");
+				const caller = await authenticate(request, "owner", "native.project");
+				const projection = await projectOwnerPhoneRequest({
+					store: captured.store,
+					clock: captured.clock,
+					caller,
+					requestId: canonicalIdentifier(third, "operationId", INVALID)
+				});
+				return jsonResponse(200, projection);
+			}
+			if (segments.length === 3 && group === "decisions") {
+				requireMethod(request, "POST");
+				const caller = await authenticate(request, "owner", "native.decide");
+				const command = phoneDecisionCommand(await bodyRecord(request, captured.maxBodyBytes));
+				const decided = await submitOwnerPhoneDecision({
+					store: captured.store,
+					clock: captured.clock,
+					kms: captured.kms,
+					caller,
+					operationId: canonicalIdentifier(third, "operationId", INVALID),
+					command,
+					codeTtlMs: captured.codeTtlMs
+				});
+				return jsonResponse(200, decided);
+			}
+			return relayFailure("relay_not_found", "route does not exist");
+		}
+		if (head === "bootstrap" && segments.length === 1) {
+			requireMethod(request, "GET");
+			await authenticate(request, "client", "bootstrap.fetch");
+			if (captured.bootstrap === null) return relayFailure("relay_not_found", "route does not exist");
+			return jsonResponse(200, captured.bootstrap);
+		}
+		if (head === "session-signers") {
+			const custody = captured.sessionSigner;
+			if (custody === null) return relayFailure("relay_not_found", "route does not exist");
+			if (segments.length === 1) {
+				requireMethod(request, "POST");
+				const caller = await authenticate(request, "client", "session-signers.credential");
+				const body = exactBody(await bodyRecord(request, captured.maxBodyBytes), ["deviceId"]);
+				const deviceId = boundedText(body.deviceId, 256, "session signer deviceId", INVALID);
+				let credential;
+				try {
+					credential = await custody.provider.credential({
+						clientId: caller.clientId,
+						subject: caller.subject,
+						deviceId
+					});
+				} catch {
+					return relayFailure("relay_internal", "session signer provider did not answer");
+				}
+				return jsonResponse(200, { operatorCredential: credential });
+			}
+			if (segments.length === 2 && group === "signatures") {
+				requireMethod(request, "POST");
+				const caller = await authenticate(request, "client", "session-signers.sign");
+				const body = exactBody(await bodyRecord(request, captured.maxBodyBytes), ["deviceId", "hash"]);
+				const deviceId = boundedText(body.deviceId, 256, "session signer deviceId", INVALID);
+				if (typeof body.hash !== "string" || !/^0x[0-9a-f]{64}$/u.test(body.hash)) return relayFailure(INVALID, "session signer hash must be one exact 32-byte hash");
+				let signature;
+				try {
+					signature = await custody.provider.sign({
+						clientId: caller.clientId,
+						subject: caller.subject,
+						deviceId,
+						hash: body.hash
+					});
+				} catch {
+					return relayFailure("relay_internal", "session signer provider did not answer");
+				}
+				return jsonResponse(200, { signature });
+			}
+			return relayFailure("relay_not_found", "route does not exist");
+		}
+		if (head === "invalidations" && segments.length === 1) {
+			requireMethod(request, "POST");
+			const caller = await authenticate(request, "client", "invalidations.create");
+			const body = exactBody(await bodyRecord(request, captured.maxBodyBytes), ["grantId", "capabilityHash"]);
+			const grantId = canonicalIdentifier(body.grantId, "grantId", INVALID);
+			const capabilityHash = boundedText(body.capabilityHash, 66, "capabilityHash", INVALID);
+			if (!/^0x[0-9a-f]{64}$/u.test(capabilityHash)) return relayFailure(INVALID, "capabilityHash must be a lowercase 32-byte hash");
+			const record = await withRelayTransaction(captured.store, async (transaction) => {
+				const existing = await transaction.lockCapabilityInvalidation(grantId);
+				if (existing) {
+					if (existing.clientId !== caller.clientId) return relayFailure("relay_not_found", "grant does not exist");
+					return existing;
+				}
+				const created = Object.freeze({
+					version: OAATH_CAPABILITY_INVALIDATION_RECORD_VERSION,
+					grantId,
+					clientId: caller.clientId,
+					capabilityHash,
+					invalidatedAt: relayNow(captured.clock)
+				});
+				if (!await transaction.insertCapabilityInvalidation(created)) return relayFailure("relay_internal", "capability invalidation did not commit");
+				return created;
+			});
+			const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(`oaath-relay-invalidation:v1:${record.clientId}:${record.grantId}:${record.capabilityHash}:${record.invalidatedAt}`));
+			const evidenceHash = `0x${[...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+			return jsonResponse(200, {
+				evidenceHash,
+				invalidatedAt: Math.floor(record.invalidatedAt / 1e3)
+			});
+		}
+		if (head === "chains" && segments.length === 4 && third === "paymaster") {
+			requireMethod(request, "POST");
+			const service = captured.paymasterServices.get(Number(group));
+			const method = fourth === "stub-data" || fourth === "data" ? fourth : null;
+			if (service === void 0 || method === null) return relayFailure("relay_not_found", "route does not exist");
+			const result = await invokePaymasterService(service, method, await authenticate(request, "client", `chains.paymaster.${method}`), exactBody(await bodyRecord(request, captured.maxBodyBytes), ["params"]).params);
+			return jsonResponse(200, result === void 0 ? {
+				present: false,
+				result: null
+			} : {
+				present: true,
+				result
+			});
+		}
+		if (head === "chains") {
+			if (segments.length !== 3) return relayFailure("relay_not_found", "route does not exist");
+			requireMethod(request, "POST");
+			const port = captured.chains.get(Number(group));
+			const name = third === "submissions" ? "submission" : third === "reads" || third === "observation" || third === "bundler" || third === "quote" || third === "usage" ? third : null;
+			if (!port || name === null) return relayFailure("relay_not_found", "route does not exist");
+			const caller = await authenticate(request, name === "submission" ? ["client", "owner"] : "client", `chains.${name}`);
+			const body = exactBody(await bodyRecord(request, captured.maxBodyBytes), ["request"]);
+			const capability = name === "usage" ? port.usage : port[name];
+			if (capability === null) return relayFailure("relay_not_found", "route does not exist");
+			const grantId = caller.role === "owner" ? null : chainRequestGrantId(name, body.request);
+			if (grantId !== null) {
+				if (await withRelayTransaction(captured.store, (transaction) => transaction.lockCapabilityInvalidation(grantId)) !== void 0) return relayFailure("relay_capability_invalidated", "the Grant's capability is invalidated");
+			}
+			let result;
+			try {
+				result = await capability(body.request);
+			} catch {
+				return relayFailure("relay_chain_unavailable", "chain port did not answer");
+			}
+			return jsonResponse(200, result === void 0 ? {
+				present: false,
+				result: null
+			} : {
+				present: true,
+				result
+			});
+		}
+		if (head !== "authorization") relayFailure("relay_not_found", "route does not exist");
+		if (segments.length === 2 && group === "requests") {
+			requireMethod(request, "POST");
+			const caller = await authenticate(request, "client", "authorization.create");
+			const body = exactBody(await bodyRecord(request, captured.maxBodyBytes), [
+				"redirectUri",
+				"codeChallenge",
+				"requestedScope"
+			]);
+			const created = await createAuthorizationRequest({
+				store: captured.store,
+				clock: captured.clock,
+				caller,
+				redirectUri: boundedText(body.redirectUri, RELAY_LIMITS.redirectUri, "redirectUri", INVALID),
+				codeChallenge: boundedText(body.codeChallenge, RELAY_LIMITS.codeChallenge, "codeChallenge", INVALID),
+				requestedScope: boundedText(body.requestedScope, RELAY_LIMITS.requestedScope, "requestedScope", INVALID),
+				requestTtlMs: captured.requestTtlMs
+			});
+			return jsonResponse(201, created);
+		}
+		if (segments.length === 3 && group === "requests") {
+			requireMethod(request, "GET");
+			const caller = await authenticate(request, "owner", "authorization.fetch");
+			const state = await fetchAuthorizationRequest({
+				store: captured.store,
+				clock: captured.clock,
+				caller,
+				requestId: canonicalIdentifier(third, "requestId", INVALID)
+			});
+			return jsonResponse(200, stateBody(state));
+		}
+		if (segments.length === 4 && group === "requests" && fourth === "decision") {
+			requireMethod(request, "POST");
+			const caller = await authenticate(request, "owner", "authorization.decide");
+			const command = decisionCommand(await bodyRecord(request, captured.maxBodyBytes));
+			const decided = await submitAuthorizationDecision({
+				store: captured.store,
+				clock: captured.clock,
+				kms: captured.kms,
+				caller,
+				requestId: canonicalIdentifier(third, "requestId", INVALID),
+				command,
+				codeTtlMs: captured.codeTtlMs
+			});
+			return jsonResponse(200, decided);
+		}
+		if (segments.length === 4 && group === "requests" && fourth === "code") {
+			requireMethod(request, "GET");
+			const caller = await authenticate(request, "client", "authorization.code");
+			const fetched = await fetchAuthorizationCode({
+				store: captured.store,
+				clock: captured.clock,
+				kms: captured.kms,
+				caller,
+				requestId: canonicalIdentifier(third, "requestId", INVALID)
+			});
+			return jsonResponse(200, fetched);
+		}
+		if (segments.length === 3 && group === "codes" && third === "consume") {
+			requireMethod(request, "POST");
+			const caller = await authenticate(request, "client", "authorization.consume");
+			const body = exactBody(await bodyRecord(request, captured.maxBodyBytes), [
+				"code",
+				"codeVerifier",
+				"redirectUri"
+			]);
+			const consumed = await consumeAuthorizationCode({
+				store: captured.store,
+				clock: captured.clock,
+				caller,
+				code: canonicalIdentifier(body.code, "code", INVALID),
+				codeVerifier: boundedText(body.codeVerifier, RELAY_LIMITS.codeVerifier, "codeVerifier", INVALID),
+				redirectUri: boundedText(body.redirectUri, RELAY_LIMITS.redirectUri, "redirectUri", INVALID)
+			});
+			return jsonResponse(200, consumed);
+		}
+		if (segments.length === 4 && group === "artifacts" && fourth === "claim") {
+			requireMethod(request, "POST");
+			const caller = await authenticate(request, "client", "authorization.claim");
+			const claimed = await claimEncryptedArtifact({
+				store: captured.store,
+				clock: captured.clock,
+				kms: captured.kms,
+				caller,
+				artifactId: canonicalIdentifier(third, "artifactId", INVALID)
+			});
+			return jsonResponse(200, claimed);
+		}
+		if (segments.length === 2 && group === "resume") {
+			requireMethod(request, "POST");
+			const caller = await authenticate(request, "client", "authorization.resume");
+			const body = exactBody(await bodyRecord(request, captured.maxBodyBytes), ["requestId"]);
+			const state = await resumeAuthorization({
+				store: captured.store,
+				clock: captured.clock,
+				caller,
+				requestId: canonicalIdentifier(body.requestId, "requestId", INVALID)
+			});
+			return jsonResponse(200, stateBody(state));
+		}
+		return relayFailure("relay_not_found", "route does not exist");
+	};
+	return async (request) => {
+		try {
+			return await route(request);
+		} catch (error) {
+			return relayErrorResponse(relayErrorCode(error));
+		}
+	};
+}
+//#endregion
+//#region src/security/redact.ts
+/**
+* Bounded credential and URL redaction for diagnostics only.
+*
+* Nothing here shapes a response or a machine decision. Its only job is to make
+* an adopter's log line safe and finite: no authorization code, verifier, token,
+* artifact, ciphertext, credential-bearing URL, or unbounded provider blob.
+*
+* @author taek <leekt216@gmail.com>
+*/
+const REDACTED = "[redacted]";
+const UNREADABLE_URL = "[unreadable-url]";
+const TRUNCATED = "[truncated]";
+const MAX_TEXT = 128;
+const MAX_DEPTH = 3;
+const MAX_ENTRIES = 16;
+/** Key names whose values are never safe to log, matched after normalization. */
+const SENSITIVE_KEYS = /* @__PURE__ */ new Set([
+	"apikey",
+	"artifact",
+	"authorization",
+	"bearer",
+	"ciphertext",
+	"ciphertextref",
+	"clientsecret",
+	"code",
+	"codechallenge",
+	"codeverifier",
+	"cookie",
+	"credential",
+	"idtoken",
+	"key",
+	"password",
+	"plaintext",
+	"privatekey",
+	"secret",
+	"session",
+	"sessionkey",
+	"setcookie",
+	"signature",
+	"token",
+	"verifier"
+]);
+function normalizeKey(key) {
+	return key.toLowerCase().replaceAll(/[^a-z0-9]/gu, "");
+}
+function isUrlKey(normalized) {
+	return normalized.endsWith("url") || normalized.endsWith("uri");
+}
+function boundText(value) {
+	return value.length <= MAX_TEXT ? value : `${value.slice(0, MAX_TEXT)}${TRUNCATED}`;
+}
+/** Keeps scheme, host, and path. Drops userinfo, query, and fragment. */
+function redactUrl(value) {
+	if (typeof value !== "string") return UNREADABLE_URL;
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return UNREADABLE_URL;
+	}
+	const port = url.port === "" ? "" : `:${url.port}`;
+	return boundText(`${url.protocol}//${url.hostname}${port}${url.pathname}`);
+}
+function redactValue(value, depth) {
+	if (value === null) return null;
+	switch (typeof value) {
+		case "string": return boundText(value);
+		case "number": return Number.isFinite(value) ? value : String(value);
+		case "boolean": return value;
+		case "bigint": return boundText(value.toString());
+		case "object": break;
+		default: return REDACTED;
+	}
+	if (depth >= MAX_DEPTH) return REDACTED;
+	if (Array.isArray(value)) {
+		const items = value.slice(0, MAX_ENTRIES).map((item) => redactValue(item, depth + 1));
+		return value.length > MAX_ENTRIES ? [...items, TRUNCATED] : items;
+	}
+	if (value instanceof Error) return {
+		name: boundText(value.name),
+		message: REDACTED
+	};
+	return redactRecord(value, depth);
+}
+function redactRecord(value, depth) {
+	const redacted = {};
+	let entries = 0;
+	for (const key of Object.keys(value)) {
+		if (entries >= MAX_ENTRIES) {
+			redacted[TRUNCATED] = true;
+			break;
+		}
+		entries += 1;
+		const normalized = normalizeKey(key);
+		if (SENSITIVE_KEYS.has(normalized)) redacted[key] = REDACTED;
+		else if (isUrlKey(normalized)) redacted[key] = redactUrl(value[key]);
+		else redacted[key] = redactValue(value[key], depth + 1);
+	}
+	return redacted;
+}
+/** Returns a bounded, credential-free projection safe to hand to a logger. */
+function redactForLog(value) {
+	return redactValue(value, 0);
+}
+//#endregion
+//#region src/session-signer/kms-provider.ts
+/**
+* Reference hosted session-signer provider: one KMS-sealed secp256k1 operator
+* key per authenticated `(clientId, subject, deviceId)` identity, signing one
+* exact 32-byte hash at a time.
+*
+* Custody boundary: the private scalar exists in plaintext only inside this
+* process during key generation and signing; at rest it is exactly one
+* KMS-sealed string. No route, log, or return value ever carries key material
+* — `credential` answers the public operator profile and `sign` answers one
+* 65-byte ECDSA signature.
+*
+* Rotation invariant: one identity maps to one credential for this provider's
+* lifetime. There is no rotation path here — a new key requires a new
+* identity, and therefore a newly approved Grant; nothing can silently swap
+* the public key under an existing approval.
+*
+* Like `createMemoryRelayStore`, the in-memory registry makes this a
+* reference implementation, not a production durability claim: a deployment
+* that must survive restarts persists the sealed entries in its own store.
+*
+* @author taek <leekt216@gmail.com>
+*/
+const HASH = /^0x[0-9a-f]{64}$/u;
+const MAX_IDENTITY_PART = 256;
+function identityKey(request) {
+	for (const part of [
+		request.clientId,
+		request.subject,
+		request.deviceId
+	]) if (typeof part !== "string" || part.length < 1 || part.length > MAX_IDENTITY_PART) throw new Error("session signer identity is invalid");
+	return JSON.stringify([
+		request.clientId,
+		request.subject,
+		request.deviceId
+	]);
+}
+function addressOf(privateKey) {
+	const publicKey = secp256k1.getPublicKey(privateKey, false);
+	return `0x${bytesToHex(keccak_256(publicKey.slice(1)).slice(12))}`;
+}
+function createKmsSessionSignerProvider(input) {
+	const kms = input.kms;
+	/** identity -> KMS-sealed private scalar; the only at-rest key form. */
+	const sealed = /* @__PURE__ */ new Map();
+	/** Serializes first-use creation so one identity never mints two keys. */
+	const creating = /* @__PURE__ */ new Map();
+	async function sealedKeyFor(identity) {
+		const existing = sealed.get(identity);
+		if (existing !== void 0) return existing;
+		const pending = creating.get(identity) ?? (async () => {
+			const scalar = secp256k1.utils.randomPrivateKey();
+			const reference = String(await kms.encrypt(bytesToHex(scalar)));
+			scalar.fill(0);
+			sealed.set(identity, reference);
+			return reference;
+		})();
+		creating.set(identity, pending);
+		pending.finally(() => creating.delete(identity));
+		return pending;
+	}
+	return Object.freeze({
+		async credential(request) {
+			const identity = identityKey(request);
+			const privateKey = hexToBytes(String(await kms.decrypt(await sealedKeyFor(identity))));
+			try {
+				return Object.freeze({
+					version: OAATH_OPERATOR_CREDENTIAL_PROFILE_VERSION,
+					kind: "ecdsa",
+					address: addressOf(privateKey)
+				});
+			} finally {
+				privateKey.fill(0);
+			}
+		},
+		async sign(request) {
+			const identity = identityKey(request);
+			if (typeof request.hash !== "string" || !HASH.test(request.hash)) throw new Error("session signer hash must be one exact 32-byte hash");
+			const reference = sealed.get(identity);
+			if (reference === void 0) throw new Error("session signer identity holds no credential");
+			const privateKey = hexToBytes(String(await kms.decrypt(reference)));
+			try {
+				const signature = secp256k1.sign(hexToBytes(request.hash.slice(2)), privateKey, { lowS: true });
+				if (signature.recovery !== 0 && signature.recovery !== 1) throw new Error("session signer produced an unusable signature");
+				return `0x${bytesToHex(signature.toCompactRawBytes())}${(27 + signature.recovery).toString(16)}`;
+			} finally {
+				privateKey.fill(0);
+			}
+		}
+	});
+}
+//#endregion
+//#region src/store/memory.ts
+/**
+* In-memory relay store implementing the same transaction contract as
+* PostgreSQL. It is durable only for the life of the process: use it for local
+* development and tests, never for a deployment that must survive a restart.
+*
+* ponytail: one process-wide writer lock stands in for row locks. It is strictly
+* stronger than `SELECT ... FOR UPDATE`, so one-shot semantics are identical;
+* swap in per-row locks only if a single-process relay ever needs throughput.
+*
+* @author taek <leekt216@gmail.com>
+*/
+function emptyTables() {
+	return {
+		requests: /* @__PURE__ */ new Map(),
+		decisions: /* @__PURE__ */ new Map(),
+		codes: /* @__PURE__ */ new Map(),
+		artifacts: /* @__PURE__ */ new Map(),
+		invalidations: /* @__PURE__ */ new Map()
+	};
+}
+function copyTables(tables) {
+	return {
+		requests: new Map(tables.requests),
+		decisions: new Map(tables.decisions),
+		codes: new Map(tables.codes),
+		artifacts: new Map(tables.artifacts),
+		invalidations: new Map(tables.invalidations)
+	};
+}
+function insert(table, key, record) {
+	if (table.has(key)) return false;
+	table.set(key, record);
+	return true;
+}
+function read(table, key, parse) {
+	const stored = table.get(key);
+	return stored === void 0 ? void 0 : parse(stored);
+}
+function createMemoryRelayStore() {
+	let committed = emptyTables();
+	let closed = false;
+	let tail = Promise.resolve();
+	async function acquire() {
+		const prior = tail;
+		let release = () => {};
+		tail = new Promise((resolve) => {
+			release = resolve;
+		});
+		await prior;
+		return release;
+	}
+	return {
+		async begin() {
+			if (closed) relayFailure("relay_store_unavailable", "memory relay store is closed");
+			const release = await acquire();
+			const staged = copyTables(committed);
+			let settled = false;
+			const open = () => {
+				if (settled) relayFailure("relay_internal", "relay transaction already settled");
+				return staged;
+			};
+			const settle = (apply) => {
+				if (settled) relayFailure("relay_internal", "relay transaction already settled");
+				settled = true;
+				if (apply) committed = staged;
+				release();
+			};
+			return {
+				async lockAuthorizationRequest(requestId) {
+					return read(open().requests, requestId, parseAuthorizationRequestRecord);
+				},
+				async insertAuthorizationRequest(record) {
+					return insert(open().requests, record.requestId, record);
+				},
+				async lockAuthorizationDecision(requestId) {
+					return read(open().decisions, requestId, parseAuthorizationDecisionRecord);
+				},
+				async insertAuthorizationDecision(record) {
+					return insert(open().decisions, record.requestId, record);
+				},
+				async lockAuthorizationCode(codeHash) {
+					return read(open().codes, codeHash, parseAuthorizationCodeRecord);
+				},
+				async insertAuthorizationCode(record) {
+					return insert(open().codes, record.codeHash, record);
+				},
+				async consumeAuthorizationCode(codeHash, consumedAt) {
+					const codes = open().codes;
+					const record = read(codes, codeHash, parseAuthorizationCodeRecord);
+					if (!record || record.consumedAt !== null) return false;
+					codes.set(codeHash, Object.freeze({
+						...record,
+						consumedAt
+					}));
+					return true;
+				},
+				async lockCapabilityInvalidation(grantId) {
+					return read(open().invalidations, grantId, parseCapabilityInvalidationRecord);
+				},
+				async insertCapabilityInvalidation(record) {
+					return insert(open().invalidations, record.grantId, record);
+				},
+				async lockEncryptedArtifact(artifactId) {
+					return read(open().artifacts, artifactId, parseEncryptedArtifactRecord);
+				},
+				async insertEncryptedArtifact(record) {
+					return insert(open().artifacts, record.artifactId, record);
+				},
+				async claimEncryptedArtifact(artifactId, claimedAt) {
+					const artifacts = open().artifacts;
+					const record = read(artifacts, artifactId, parseEncryptedArtifactRecord);
+					if (!record || record.claimedAt !== null) return false;
+					artifacts.set(artifactId, Object.freeze({
+						...record,
+						claimedAt
+					}));
+					return true;
+				},
+				async commit() {
+					settle(true);
+				},
+				async rollback() {
+					if (!settled) settle(false);
+				}
+			};
+		},
+		async close() {
+			closed = true;
+			committed = emptyTables();
+		}
+	};
+}
+//#endregion
+export { OAATH_AUTHORIZATION_CODE_RECORD_VERSION, OAATH_AUTHORIZATION_DECISION_RECORD_VERSION, OAATH_AUTHORIZATION_REQUEST_RECORD_VERSION, OAATH_ENCRYPTED_ARTIFACT_RECORD_VERSION, OaathRelayError, REDACTED, RELAY_ERROR_STATUS, claimEncryptedArtifact, consumeAuthorizationCode, createAuthorizationRequest, createKmsSessionSignerProvider, createMemoryRelayStore, createRelayHandler, fetchAuthorizationRequest, isCodeChallengeS256, openArtifact, redactForLog, redactUrl, resumeAuthorization, sealArtifact, submitAuthorizationDecision, verifyPkceS256 };
+
+//# sourceMappingURL=index.js.map