@seams/wallet-server 0.6.2 → 0.7.1

package/dist/esm/core/WebAuthnAuthenticatorStore.js

@@ -1,9 +1,9 @@
-import { parseWebAuthnAuthenticatorDeviceInfo, parseWebAuthnAuthenticatorDeviceInfoJson, unknownWebAuthnAuthenticatorDeviceInfo } from "../shared-ts/src/utils/webauthnDeviceInfo.js";
 import { normalizeOptionalTrimmedString } from "../shared-ts/src/utils/normalize.js";
-import { isObject as isObject$1 } from "../shared-ts/src/utils/validation.js";
-import { formatD1ExecStatement, resolveD1DatabaseFromConfig } from "../storage/d1Sql.js";
-import "./defaultConfigsServer.js";
-import { RedisTcpClient, UpstashRedisRestClient, redisDel, redisGetJson, redisSetJson } from "./ThresholdService/kv.js";
+import { isObject } from "../shared-ts/src/utils/validation.js";
+import { parseWebAuthnAuthenticatorDeviceInfo, parseWebAuthnAuthenticatorDeviceInfoJson, unknownWebAuthnAuthenticatorDeviceInfo } from "../shared-ts/src/utils/webauthnDeviceInfo.js";
+import { D1TenantTable, ensureD1Schema } from "./d1TenantStore.js";
+import { UPSERT_WEBAUTHN_AUTHENTICATOR_SQL, webAuthnAuthenticatorRows } from "./webAuthnD1Statements.js";
+import { WebAuthnCredentialRecords, createWebAuthnStore, resolveWebAuthnStorePrefix, webAuthnD1Store } from "./webAuthnStoreBackends.js";
 //#region src/core/WebAuthnAuthenticatorStore.ts
 const WEBAUTHN_AUTHENTICATOR_STORE_D1_SCHEMA_SQL = Object.freeze([`
     CREATE TABLE IF NOT EXISTS webauthn_authenticators (
@@ -38,20 +38,20 @@ const WEBAUTHN_AUTHENTICATOR_STORE_D1_SCHEMA_SQL = Object.freeze([`
       )
   `]);
 async function ensureWebAuthnAuthenticatorStoreD1Schema(options) {
-	for (const statement of WEBAUTHN_AUTHENTICATOR_STORE_D1_SCHEMA_SQL) await options.database.exec(formatD1ExecStatement(statement));
-}
-function isObject(v) {
-	return isObject$1(v);
-}
-function toPrefixWithColon(prefix, defaultPrefix) {
-	const p = normalizeOptionalTrimmedString(prefix);
-	if (!p) return defaultPrefix;
-	return p.endsWith(":") ? p : `${p}:`;
+	await ensureD1Schema(options.database, WEBAUTHN_AUTHENTICATOR_STORE_D1_SCHEMA_SQL);
 }
+const AUTHENTICATOR_STORE = {
+	label: "authenticator",
+	prefixConfigKey: "WEBAUTHN_AUTHENTICATOR_PREFIX",
+	prefixName: "authenticator",
+	parse: parseWebAuthnAuthenticatorRecord,
+	durableObjectLogSubject: "authenticator persistence",
+	connectionErrorSubject: "webauthn store",
+	unconfiguredNote: "non-persistent",
+	d1ScopeLabel: "authenticator"
+};
 function resolveWebAuthnAuthenticatorStoreNamespace(config) {
-	const explicit = normalizeOptionalTrimmedString(config.WEBAUTHN_AUTHENTICATOR_PREFIX);
-	if (explicit) return toPrefixWithColon(explicit, "");
-	return `${toPrefixWithColon(normalizeOptionalTrimmedString(config.THRESHOLD_PREFIX) || "w3a", `w3a:`)}webauthn:authenticator:`;
+	return resolveWebAuthnStorePrefix(config, AUTHENTICATOR_STORE);
 }
 function parseWebAuthnAuthenticatorRecord(raw) {
 	if (!isObject(raw)) return null;
@@ -76,29 +76,6 @@ function parseWebAuthnAuthenticatorRecord(raw) {
 		deviceInfo: parseWebAuthnAuthenticatorDeviceInfo(raw.deviceInfo) ?? unknownWebAuthnAuthenticatorDeviceInfo()
 	};
 }
-function requireD1ScopeString(input, field) {
-	const normalized = normalizeOptionalTrimmedString(input);
-	if (!normalized) throw new Error(`${field} is required for D1 WebAuthn authenticator store`);
-	return normalized;
-}
-function normalizeD1WebAuthnAuthenticatorStoreOptions(input) {
-	return {
-		database: input.database,
-		namespace: requireD1ScopeString(input.namespace, "namespace"),
-		orgId: requireD1ScopeString(input.orgId, "orgId"),
-		projectId: requireD1ScopeString(input.projectId, "projectId"),
-		envId: requireD1ScopeString(input.envId, "envId"),
-		ensureSchema: input.ensureSchema !== false
-	};
-}
-function d1ScopeFromConfig(input) {
-	return {
-		namespace: requireD1ScopeString(input.namespace, "namespace"),
-		orgId: requireD1ScopeString(input.config.orgId || input.config.ORG_ID, "orgId"),
-		projectId: requireD1ScopeString(input.config.projectId || input.config.PROJECT_ID, "projectId"),
-		envId: requireD1ScopeString(input.config.envId || input.config.ENV_ID, "envId")
-	};
-}
 function parseD1WebAuthnAuthenticatorRow(row) {
 	if (!row) return null;
 	return parseWebAuthnAuthenticatorRecord({
@@ -111,39 +88,37 @@ function parseD1WebAuthnAuthenticatorRow(row) {
 		deviceInfo: parseWebAuthnAuthenticatorDeviceInfoJson(row.device_info_json)
 	});
 }
-var InMemoryWebAuthnAuthenticatorStore = class {
-	constructor(prefix) {
-		this.map = /* @__PURE__ */ new Map();
-		this.prefix = prefix;
-	}
-	key(userId, credentialIdB64u) {
-		return `${this.prefix}${userId}:${credentialIdB64u}`;
+var KeyValueWebAuthnAuthenticatorStore = class {
+	constructor(records, prefix) {
+		this.records = new WebAuthnCredentialRecords(records, prefix);
 	}
 	async get(userId, credentialIdB64u) {
-		const uid = normalizeOptionalTrimmedString(userId);
-		const cid = normalizeOptionalTrimmedString(credentialIdB64u);
-		if (!uid || !cid) return null;
-		return this.map.get(this.key(uid, cid)) || null;
+		return this.records.get(userId, credentialIdB64u);
 	}
 	async put(userId, record) {
 		const uid = normalizeOptionalTrimmedString(userId);
 		if (!uid) throw new Error("Missing userId");
 		const parsed = parseWebAuthnAuthenticatorRecord(record);
 		if (!parsed) throw new Error("Invalid authenticator record");
-		this.map.set(this.key(uid, parsed.credentialIdB64u), parsed);
+		await this.records.set(uid, parsed.credentialIdB64u, parsed);
 	}
 	async del(userId, credentialIdB64u) {
-		const uid = normalizeOptionalTrimmedString(userId);
-		const cid = normalizeOptionalTrimmedString(credentialIdB64u);
-		if (!uid || !cid) return;
-		this.map.delete(this.key(uid, cid));
+		await this.records.del(userId, credentialIdB64u);
+	}
+};
+/** Only the in-memory backend can enumerate a user's authenticators. */
+var InMemoryWebAuthnAuthenticatorStore = class extends KeyValueWebAuthnAuthenticatorStore {
+	constructor(memory, prefix) {
+		super(memory, prefix);
+		this.memory = memory;
+		this.prefix = prefix;
 	}
 	async list(userId) {
 		const uid = normalizeOptionalTrimmedString(userId);
 		if (!uid) return [];
 		const keyPrefix = `${this.prefix}${uid}:`;
 		const out = [];
-		for (const [k, v] of this.map.entries()) {
+		for (const [k, v] of this.memory.map.entries()) {
 			if (!k.startsWith(keyPrefix)) continue;
 			const parsed = parseWebAuthnAuthenticatorRecord(v);
 			if (parsed) out.push(parsed);
@@ -155,96 +130,57 @@ var InMemoryWebAuthnAuthenticatorStore = class {
 var D1WebAuthnAuthenticatorStore = class {
 	constructor(input) {
 		this.adapterKind = "d1";
-		this.schemaReady = false;
-		const normalized = normalizeD1WebAuthnAuthenticatorStoreOptions(input);
-		this.database = normalized.database;
-		this.scope = {
-			namespace: normalized.namespace,
-			orgId: normalized.orgId,
-			projectId: normalized.projectId,
-			envId: normalized.envId
-		};
-		this.ensureSchemaOnUse = normalized.ensureSchema;
-	}
-	async ensureSchema() {
-		if (!this.ensureSchemaOnUse || this.schemaReady) return;
-		await ensureWebAuthnAuthenticatorStoreD1Schema({ database: this.database });
-		this.schemaReady = true;
+		this.prepare = (sql, values) => this.table.prepare(sql, values);
+		this.table = new D1TenantTable(input, webAuthnD1Store(AUTHENTICATOR_STORE.d1ScopeLabel), WEBAUTHN_AUTHENTICATOR_STORE_D1_SCHEMA_SQL);
 	}
 	async get(userId, credentialIdB64u) {
-		await this.ensureSchema();
+		await this.table.ensureSchema();
 		const uid = normalizeOptionalTrimmedString(userId);
 		const cid = normalizeOptionalTrimmedString(credentialIdB64u);
 		if (!uid || !cid) return null;
-		return parseD1WebAuthnAuthenticatorRow(await this.database.prepare(`SELECT credential_id_b64u, credential_public_key_b64u, counter, created_at_ms, updated_at_ms, device_info_json
-           FROM webauthn_authenticators
-          WHERE namespace = ?
-            AND org_id = ?
-            AND project_id = ?
-            AND env_id = ?
-            AND user_id = ?
-            AND credential_id_b64u = ?
-          LIMIT 1`).bind(this.scope.namespace, this.scope.orgId, this.scope.projectId, this.scope.envId, uid, cid).first());
+		return parseD1WebAuthnAuthenticatorRow(await webAuthnAuthenticatorRows.select(this.prepare, uid, cid).first());
 	}
 	async put(userId, record) {
-		await this.ensureSchema();
+		await this.table.ensureSchema();
 		const uid = normalizeOptionalTrimmedString(userId);
 		if (!uid) throw new Error("Missing userId");
 		const parsed = parseWebAuthnAuthenticatorRecord(record);
 		if (!parsed) throw new Error("Invalid authenticator record");
-		await this.database.prepare(`INSERT INTO webauthn_authenticators (
-          namespace,
-          org_id,
-          project_id,
-          env_id,
-          user_id,
-          credential_id_b64u,
-          credential_public_key_b64u,
-          counter,
-          created_at_ms,
-          updated_at_ms,
-          device_info_json
-        )
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        ON CONFLICT (namespace, org_id, project_id, env_id, user_id, credential_id_b64u)
-        DO UPDATE SET
-          credential_public_key_b64u = EXCLUDED.credential_public_key_b64u,
-          counter = MAX(webauthn_authenticators.counter, EXCLUDED.counter),
-          created_at_ms = MIN(
-            webauthn_authenticators.created_at_ms,
-            EXCLUDED.created_at_ms
-          ),
-          updated_at_ms = MAX(
-            webauthn_authenticators.updated_at_ms,
-            EXCLUDED.updated_at_ms
-          ),
-          device_info_json = EXCLUDED.device_info_json`).bind(this.scope.namespace, this.scope.orgId, this.scope.projectId, this.scope.envId, uid, parsed.credentialIdB64u, parsed.credentialPublicKeyB64u, parsed.counter, parsed.createdAtMs, parsed.updatedAtMs, JSON.stringify(parsed.deviceInfo)).run();
+		await this.table.prepare(UPSERT_WEBAUTHN_AUTHENTICATOR_SQL, [
+			uid,
+			parsed.credentialIdB64u,
+			parsed.credentialPublicKeyB64u,
+			parsed.counter,
+			parsed.createdAtMs,
+			parsed.updatedAtMs,
+			JSON.stringify(parsed.deviceInfo)
+		]).run();
 	}
 	async del(userId, credentialIdB64u) {
-		await this.ensureSchema();
+		await this.table.ensureSchema();
 		const uid = normalizeOptionalTrimmedString(userId);
 		const cid = normalizeOptionalTrimmedString(credentialIdB64u);
 		if (!uid || !cid) return;
-		await this.database.prepare(`DELETE FROM webauthn_authenticators
+		await this.table.prepare(`DELETE FROM webauthn_authenticators
           WHERE namespace = ?
             AND org_id = ?
             AND project_id = ?
             AND env_id = ?
             AND user_id = ?
-            AND credential_id_b64u = ?`).bind(this.scope.namespace, this.scope.orgId, this.scope.projectId, this.scope.envId, uid, cid).run();
+            AND credential_id_b64u = ?`, [uid, cid]).run();
 	}
 	async list(userId) {
-		await this.ensureSchema();
+		await this.table.ensureSchema();
 		const uid = normalizeOptionalTrimmedString(userId);
 		if (!uid) return [];
-		const result = await this.database.prepare(`SELECT credential_id_b64u, credential_public_key_b64u, counter, created_at_ms, updated_at_ms, device_info_json
+		const result = await this.table.prepare(`SELECT credential_id_b64u, credential_public_key_b64u, counter, created_at_ms, updated_at_ms, device_info_json
            FROM webauthn_authenticators
           WHERE namespace = ?
             AND org_id = ?
             AND project_id = ?
             AND env_id = ?
             AND user_id = ?
-          ORDER BY created_at_ms ASC`).bind(this.scope.namespace, this.scope.orgId, this.scope.projectId, this.scope.envId, uid).all();
+          ORDER BY created_at_ms ASC`, [uid]).all();
 		const records = [];
 		for (const row of result.results || []) {
 			const parsed = parseD1WebAuthnAuthenticatorRow(row);
@@ -253,231 +189,12 @@ var D1WebAuthnAuthenticatorStore = class {
 		return records;
 	}
 };
-var UpstashRedisRestWebAuthnAuthenticatorStore = class {
-	constructor(input) {
-		this.client = new UpstashRedisRestClient({
-			url: input.url,
-			token: input.token
-		});
-		this.prefix = input.prefix;
-	}
-	key(userId, credentialIdB64u) {
-		return `${this.prefix}${userId}:${credentialIdB64u}`;
-	}
-	async get(userId, credentialIdB64u) {
-		const uid = normalizeOptionalTrimmedString(userId);
-		const cid = normalizeOptionalTrimmedString(credentialIdB64u);
-		if (!uid || !cid) return null;
-		return parseWebAuthnAuthenticatorRecord(await this.client.getJson(this.key(uid, cid)));
-	}
-	async put(userId, record) {
-		const uid = normalizeOptionalTrimmedString(userId);
-		if (!uid) throw new Error("Missing userId");
-		const parsed = parseWebAuthnAuthenticatorRecord(record);
-		if (!parsed) throw new Error("Invalid authenticator record");
-		await this.client.setJson(this.key(uid, parsed.credentialIdB64u), parsed);
-	}
-	async del(userId, credentialIdB64u) {
-		const uid = normalizeOptionalTrimmedString(userId);
-		const cid = normalizeOptionalTrimmedString(credentialIdB64u);
-		if (!uid || !cid) return;
-		await this.client.del(this.key(uid, cid));
-	}
-};
-var RedisTcpWebAuthnAuthenticatorStore = class {
-	constructor(input) {
-		this.client = new RedisTcpClient(input.redisUrl);
-		this.prefix = input.prefix;
-	}
-	key(userId, credentialIdB64u) {
-		return `${this.prefix}${userId}:${credentialIdB64u}`;
-	}
-	async get(userId, credentialIdB64u) {
-		const uid = normalizeOptionalTrimmedString(userId);
-		const cid = normalizeOptionalTrimmedString(credentialIdB64u);
-		if (!uid || !cid) return null;
-		return parseWebAuthnAuthenticatorRecord(await redisGetJson(this.client, this.key(uid, cid)));
-	}
-	async put(userId, record) {
-		const uid = normalizeOptionalTrimmedString(userId);
-		if (!uid) throw new Error("Missing userId");
-		const parsed = parseWebAuthnAuthenticatorRecord(record);
-		if (!parsed) throw new Error("Invalid authenticator record");
-		await redisSetJson(this.client, this.key(uid, parsed.credentialIdB64u), parsed);
-	}
-	async del(userId, credentialIdB64u) {
-		const uid = normalizeOptionalTrimmedString(userId);
-		const cid = normalizeOptionalTrimmedString(credentialIdB64u);
-		if (!uid || !cid) return;
-		await redisDel(this.client, this.key(uid, cid));
-	}
-};
-function isDurableObjectNamespaceLike(v) {
-	return Boolean(v) && typeof v === "object" && !Array.isArray(v) && typeof v.idFromName === "function" && typeof v.get === "function";
-}
-function resolveDoNamespaceFromConfig(config) {
-	const direct = config.namespace;
-	if (isDurableObjectNamespaceLike(direct)) return direct;
-	const alt = config.durableObjectNamespace;
-	if (isDurableObjectNamespaceLike(alt)) return alt;
-	const envStyle = config.THRESHOLD_DO_NAMESPACE;
-	if (isDurableObjectNamespaceLike(envStyle)) return envStyle;
-	return null;
-}
-function resolveDoStub(input) {
-	const id = input.namespace.idFromName(input.objectName);
-	return input.namespace.get(id);
-}
-async function callDo(stub, req) {
-	const resp = await stub.fetch("https://threshold-store.invalid/", {
-		method: "POST",
-		headers: { "content-type": "application/json" },
-		body: JSON.stringify(req)
-	});
-	const text = await resp.text();
-	if (!resp.ok) throw new Error(`WebAuthn DO store HTTP ${resp.status}: ${text}`);
-	let json;
-	try {
-		json = text ? JSON.parse(text) : null;
-	} catch {
-		throw new Error(`WebAuthn DO store returned non-JSON response: ${text.slice(0, 200)}`);
-	}
-	if (!isObject(json)) throw new Error("WebAuthn DO store returned invalid JSON shape");
-	if (json.ok === true) return json;
-	const code = normalizeOptionalTrimmedString(json.code);
-	const message = normalizeOptionalTrimmedString(json.message);
-	return {
-		ok: false,
-		code: code || "internal",
-		message: message || "WebAuthn DO store error"
-	};
-}
-var CloudflareDurableObjectWebAuthnAuthenticatorStore = class {
-	constructor(input) {
-		this.stub = resolveDoStub({
-			namespace: input.namespace,
-			objectName: input.objectName
-		});
-		this.prefix = input.prefix;
-	}
-	key(userId, credentialIdB64u) {
-		return `${this.prefix}${userId}:${credentialIdB64u}`;
-	}
-	async get(userId, credentialIdB64u) {
-		const uid = normalizeOptionalTrimmedString(userId);
-		const cid = normalizeOptionalTrimmedString(credentialIdB64u);
-		if (!uid || !cid) return null;
-		const resp = await callDo(this.stub, {
-			op: "get",
-			key: this.key(uid, cid)
-		});
-		if (!resp.ok) return null;
-		return parseWebAuthnAuthenticatorRecord(resp.value);
-	}
-	async put(userId, record) {
-		const uid = normalizeOptionalTrimmedString(userId);
-		if (!uid) throw new Error("Missing userId");
-		const parsed = parseWebAuthnAuthenticatorRecord(record);
-		if (!parsed) throw new Error("Invalid authenticator record");
-		const resp = await callDo(this.stub, {
-			op: "set",
-			key: this.key(uid, parsed.credentialIdB64u),
-			value: parsed
-		});
-		if (!resp.ok) throw new Error(resp.message);
-	}
-	async del(userId, credentialIdB64u) {
-		const uid = normalizeOptionalTrimmedString(userId);
-		const cid = normalizeOptionalTrimmedString(credentialIdB64u);
-		if (!uid || !cid) return;
-		const resp = await callDo(this.stub, {
-			op: "del",
-			key: this.key(uid, cid)
-		});
-		if (!resp.ok) throw new Error(resp.message);
-	}
-};
 function createWebAuthnAuthenticatorStore(input) {
-	const config = isObject(input.config) ? input.config : {};
-	const prefix = resolveWebAuthnAuthenticatorStoreNamespace(config);
-	const kind = normalizeOptionalTrimmedString(config.kind);
-	if (kind === "d1") {
-		const database = resolveD1DatabaseFromConfig(config);
-		if (!database) throw new Error("[webauthn] D1 authenticator store selected but no D1 database was provided");
-		input.logger.info("[webauthn] Using D1 authenticator store");
-		return new D1WebAuthnAuthenticatorStore({
-			database,
-			...d1ScopeFromConfig({
-				config,
-				namespace: prefix
-			})
-		});
-	}
-	if (kind === "cloudflare-do") {
-		const namespace = resolveDoNamespaceFromConfig(config);
-		if (!namespace) throw new Error("cloudflare-do webauthn store selected but no Durable Object namespace was provided (expected config.namespace)");
-		const objectName = normalizeOptionalTrimmedString(config.objectName) || normalizeOptionalTrimmedString(config.name) || "threshold-store";
-		input.logger.info("[webauthn] Using Cloudflare Durable Object store for authenticator persistence");
-		return new CloudflareDurableObjectWebAuthnAuthenticatorStore({
-			namespace,
-			objectName,
-			prefix
-		});
-	}
-	if (kind === "in-memory") {
-		input.logger.info("[webauthn] Using in-memory authenticator store (non-persistent)");
-		return new InMemoryWebAuthnAuthenticatorStore(prefix);
-	}
-	if (kind === "upstash-redis-rest") {
-		const url = normalizeOptionalTrimmedString(config.url) || normalizeOptionalTrimmedString(config.UPSTASH_REDIS_REST_URL);
-		const token = normalizeOptionalTrimmedString(config.token) || normalizeOptionalTrimmedString(config.UPSTASH_REDIS_REST_TOKEN);
-		if (!url || !token) throw new Error("Upstash webauthn store enabled but url/token are not both set");
-		input.logger.info("[webauthn] Using Upstash REST authenticator store");
-		return new UpstashRedisRestWebAuthnAuthenticatorStore({
-			url,
-			token,
-			prefix
-		});
-	}
-	if (kind === "redis-tcp") {
-		if (!input.isNode) {
-			input.logger.warn("[webauthn] redis-tcp authenticator store is not supported in this runtime; falling back to in-memory");
-			return new InMemoryWebAuthnAuthenticatorStore(prefix);
-		}
-		const redisUrl = normalizeOptionalTrimmedString(config.redisUrl) || normalizeOptionalTrimmedString(config.REDIS_URL);
-		if (!redisUrl) throw new Error("redis-tcp webauthn store enabled but redisUrl is not set");
-		input.logger.info("[webauthn] Using redis-tcp authenticator store");
-		return new RedisTcpWebAuthnAuthenticatorStore({
-			redisUrl,
-			prefix
-		});
-	}
-	if (kind) throw new Error(`[webauthn] Unknown authenticator store kind: ${kind}`);
-	const upstashUrl = normalizeOptionalTrimmedString(config.UPSTASH_REDIS_REST_URL);
-	const upstashToken = normalizeOptionalTrimmedString(config.UPSTASH_REDIS_REST_TOKEN);
-	if (upstashUrl || upstashToken) {
-		if (!upstashUrl || !upstashToken) throw new Error("Upstash webauthn store enabled but UPSTASH_REDIS_REST_URL / UPSTASH_REDIS_REST_TOKEN are not both set");
-		input.logger.info("[webauthn] Using Upstash REST authenticator store");
-		return new UpstashRedisRestWebAuthnAuthenticatorStore({
-			url: upstashUrl,
-			token: upstashToken,
-			prefix
-		});
-	}
-	const redisUrl = normalizeOptionalTrimmedString(config.REDIS_URL);
-	if (redisUrl) {
-		if (!input.isNode) {
-			input.logger.warn("[webauthn] REDIS_URL is set but TCP Redis is not supported in this runtime; falling back to in-memory");
-			return new InMemoryWebAuthnAuthenticatorStore(prefix);
-		}
-		input.logger.info("[webauthn] Using redis-tcp authenticator store");
-		return new RedisTcpWebAuthnAuthenticatorStore({
-			redisUrl,
-			prefix
-		});
-	}
-	input.logger.info("[webauthn] Using in-memory authenticator store (non-persistent)");
-	return new InMemoryWebAuthnAuthenticatorStore(prefix);
+	return createWebAuthnStore(input, AUTHENTICATOR_STORE, {
+		d1: (options) => new D1WebAuthnAuthenticatorStore(options),
+		keyValue: (records, prefix) => new KeyValueWebAuthnAuthenticatorStore(records, prefix),
+		inMemory: (records, prefix) => new InMemoryWebAuthnAuthenticatorStore(records, prefix)
+	});
 }
 //#endregion
 export { D1WebAuthnAuthenticatorStore, WEBAUTHN_AUTHENTICATOR_STORE_D1_SCHEMA_SQL, createWebAuthnAuthenticatorStore, ensureWebAuthnAuthenticatorStoreD1Schema, resolveWebAuthnAuthenticatorStoreNamespace };