@seams/wallet-server 0.5.0

package/dist/esm/core/IdentityStore.js

@@ -0,0 +1,617 @@
+import { normalizeOptionalTrimmedString } from "../shared-ts/src/utils/normalize.js";
+import { isObject as isObject$1 } from "../shared-ts/src/utils/validation.js";
+import { resolveD1DatabaseFromConfig } from "../storage/d1Sql.js";
+import "./defaultConfigsServer.js";
+import { RedisTcpClient, UpstashRedisRestClient, redisDel, redisGetJson, redisSetJson } from "./ThresholdService/kv.js";
+import { D1IdentityStore, IDENTITY_STORE_D1_SCHEMA_SQL, ensureIdentityStoreD1Schema } from "./d1IdentityStore.js";
+//#region src/core/IdentityStore.ts
+function isObject(v) {
+	return isObject$1(v);
+}
+function toPrefixWithColon(prefix, defaultPrefix) {
+	const p = normalizeOptionalTrimmedString(prefix);
+	if (!p) return defaultPrefix;
+	return p.endsWith(":") ? p : `${p}:`;
+}
+function resolveIdentityStoreNamespace(config) {
+	const explicit = normalizeOptionalTrimmedString(config.IDENTITY_PREFIX) || normalizeOptionalTrimmedString(config.IDENTITY_MAP_PREFIX);
+	if (explicit) return toPrefixWithColon(explicit, "");
+	return `${toPrefixWithColon(normalizeOptionalTrimmedString(config.THRESHOLD_PREFIX) || "w3a", `w3a:`)}identity:`;
+}
+function parseIdentitySubjectRecord(raw) {
+	if (!isObject(raw)) return null;
+	const version = normalizeOptionalTrimmedString(raw.version);
+	const subject = normalizeOptionalTrimmedString(raw.subject);
+	const userId = normalizeOptionalTrimmedString(raw.userId);
+	const createdAtMsRaw = raw.createdAtMs;
+	const updatedAtMsRaw = raw.updatedAtMs;
+	const createdAtMs = typeof createdAtMsRaw === "number" ? createdAtMsRaw : Number(createdAtMsRaw);
+	const updatedAtMs = typeof updatedAtMsRaw === "number" ? updatedAtMsRaw : Number(updatedAtMsRaw);
+	if (version !== "identity_subject_v1") return null;
+	if (!subject || !userId) return null;
+	if (!Number.isFinite(createdAtMs) || createdAtMs <= 0) return null;
+	if (!Number.isFinite(updatedAtMs) || updatedAtMs <= 0) return null;
+	return {
+		version: "identity_subject_v1",
+		subject,
+		userId,
+		createdAtMs: Math.floor(createdAtMs),
+		updatedAtMs: Math.floor(updatedAtMs)
+	};
+}
+function parseIdentityUserRecord(raw) {
+	if (!isObject(raw)) return null;
+	const version = normalizeOptionalTrimmedString(raw.version);
+	const userId = normalizeOptionalTrimmedString(raw.userId);
+	const subjectsRaw = raw.subjects;
+	const subjects = Array.isArray(subjectsRaw) ? subjectsRaw.map((s) => typeof s === "string" ? s.trim() : "").filter(Boolean) : null;
+	const createdAtMsRaw = raw.createdAtMs;
+	const updatedAtMsRaw = raw.updatedAtMs;
+	const createdAtMs = typeof createdAtMsRaw === "number" ? createdAtMsRaw : Number(createdAtMsRaw);
+	const updatedAtMs = typeof updatedAtMsRaw === "number" ? updatedAtMsRaw : Number(updatedAtMsRaw);
+	if (version !== "identity_user_v1") return null;
+	if (!userId || !subjects) return null;
+	if (!Number.isFinite(createdAtMs) || createdAtMs <= 0) return null;
+	if (!Number.isFinite(updatedAtMs) || updatedAtMs <= 0) return null;
+	const uniqueSubjects = Array.from(new Set(subjects));
+	uniqueSubjects.sort();
+	return {
+		version: "identity_user_v1",
+		userId,
+		subjects: uniqueSubjects,
+		createdAtMs: Math.floor(createdAtMs),
+		updatedAtMs: Math.floor(updatedAtMs)
+	};
+}
+function requireD1ScopeString(input, field) {
+	const normalized = normalizeOptionalTrimmedString(input);
+	if (!normalized) throw new Error(`${field} is required for D1 identity store`);
+	return normalized;
+}
+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")
+	};
+}
+var InMemoryIdentityStore = class {
+	constructor(prefix) {
+		this.subjectToUser = /* @__PURE__ */ new Map();
+		this.userToSubjects = /* @__PURE__ */ new Map();
+		this.prefix = prefix;
+	}
+	subjectKey(subject) {
+		return `${this.prefix}subject:${subject}`;
+	}
+	userKey(userId) {
+		return `${this.prefix}user:${userId}`;
+	}
+	async getUserIdBySubject(subject) {
+		const s = normalizeOptionalTrimmedString(subject);
+		if (!s) return null;
+		return this.subjectToUser.get(this.subjectKey(s))?.userId || null;
+	}
+	async listSubjectsByUserId(userId) {
+		const uid = normalizeOptionalTrimmedString(userId);
+		if (!uid) return [];
+		return this.userToSubjects.get(this.userKey(uid))?.subjects || [];
+	}
+	async linkSubjectToUserId(input) {
+		const userId = normalizeOptionalTrimmedString(input.userId);
+		const subject = normalizeOptionalTrimmedString(input.subject);
+		if (!userId) return {
+			ok: false,
+			code: "invalid_args",
+			message: "Missing userId"
+		};
+		if (!subject) return {
+			ok: false,
+			code: "invalid_args",
+			message: "Missing subject"
+		};
+		const now = Date.now();
+		const existing = this.subjectToUser.get(this.subjectKey(subject)) || null;
+		if (existing && existing.userId !== userId) {
+			if (!input.allowMoveIfSoleIdentity) return {
+				ok: false,
+				code: "already_linked",
+				message: "Subject is already linked to a different user"
+			};
+			const sourceUser = existing.userId;
+			const source = this.userToSubjects.get(this.userKey(sourceUser)) || null;
+			const sourceSubjects = source?.subjects || [];
+			if (sourceSubjects.length !== 1 || sourceSubjects[0] !== subject) return {
+				ok: false,
+				code: "already_linked",
+				message: "Subject is linked to a different user with other identities; merge is not allowed"
+			};
+			this.userToSubjects.set(this.userKey(sourceUser), {
+				version: "identity_user_v1",
+				userId: sourceUser,
+				subjects: [],
+				createdAtMs: source?.createdAtMs || now,
+				updatedAtMs: now
+			});
+			this.subjectToUser.set(this.subjectKey(subject), {
+				version: "identity_subject_v1",
+				subject,
+				userId,
+				createdAtMs: existing.createdAtMs,
+				updatedAtMs: now
+			});
+			const dest = this.userToSubjects.get(this.userKey(userId)) || null;
+			const destSubjects = Array.from(new Set([...dest?.subjects || [], subject]));
+			destSubjects.sort();
+			this.userToSubjects.set(this.userKey(userId), {
+				version: "identity_user_v1",
+				userId,
+				subjects: destSubjects,
+				createdAtMs: dest?.createdAtMs || now,
+				updatedAtMs: now
+			});
+			return {
+				ok: true,
+				movedFromUserId: sourceUser
+			};
+		}
+		if (!existing) this.subjectToUser.set(this.subjectKey(subject), {
+			version: "identity_subject_v1",
+			subject,
+			userId,
+			createdAtMs: now,
+			updatedAtMs: now
+		});
+		else this.subjectToUser.set(this.subjectKey(subject), {
+			...existing,
+			updatedAtMs: now
+		});
+		const existingUser = this.userToSubjects.get(this.userKey(userId)) || null;
+		const nextSubjects = Array.from(new Set([...existingUser?.subjects || [], subject]));
+		nextSubjects.sort();
+		this.userToSubjects.set(this.userKey(userId), {
+			version: "identity_user_v1",
+			userId,
+			subjects: nextSubjects,
+			createdAtMs: existingUser?.createdAtMs || now,
+			updatedAtMs: now
+		});
+		return { ok: true };
+	}
+	async unlinkSubjectFromUserId(input) {
+		const userId = normalizeOptionalTrimmedString(input.userId);
+		const subject = normalizeOptionalTrimmedString(input.subject);
+		if (!userId) return {
+			ok: false,
+			code: "invalid_args",
+			message: "Missing userId"
+		};
+		if (!subject) return {
+			ok: false,
+			code: "invalid_args",
+			message: "Missing subject"
+		};
+		const existing = this.subjectToUser.get(this.subjectKey(subject)) || null;
+		if (!existing || existing.userId !== userId) return {
+			ok: false,
+			code: "not_found",
+			message: "Subject is not linked to this user"
+		};
+		const userRec = this.userToSubjects.get(this.userKey(userId)) || null;
+		const subjects = userRec?.subjects || [];
+		if (subjects.length <= 1) return {
+			ok: false,
+			code: "cannot_unlink_last_identity",
+			message: "Refusing to remove the last remaining identity"
+		};
+		this.subjectToUser.delete(this.subjectKey(subject));
+		const now = Date.now();
+		const nextSubjects = subjects.filter((s) => s !== subject);
+		nextSubjects.sort();
+		this.userToSubjects.set(this.userKey(userId), {
+			version: "identity_user_v1",
+			userId,
+			subjects: nextSubjects,
+			createdAtMs: userRec?.createdAtMs || now,
+			updatedAtMs: now
+		});
+		return { ok: true };
+	}
+	async deleteSubjectLinkForDevCleanup(input) {
+		const userId = normalizeOptionalTrimmedString(input.userId);
+		const subject = normalizeOptionalTrimmedString(input.subject);
+		if (!userId) return {
+			ok: false,
+			code: "invalid_args",
+			message: "Missing userId"
+		};
+		if (!subject) return {
+			ok: false,
+			code: "invalid_args",
+			message: "Missing subject"
+		};
+		const existing = this.subjectToUser.get(this.subjectKey(subject)) || null;
+		if (!existing || existing.userId !== userId) return {
+			ok: false,
+			code: "not_found",
+			message: "Subject is not linked to this user"
+		};
+		this.subjectToUser.delete(this.subjectKey(subject));
+		const now = Date.now();
+		const userRec = this.userToSubjects.get(this.userKey(userId)) || null;
+		const nextSubjects = (userRec?.subjects || []).filter((s) => s !== subject);
+		if (nextSubjects.length > 0) {
+			nextSubjects.sort();
+			this.userToSubjects.set(this.userKey(userId), {
+				version: "identity_user_v1",
+				userId,
+				subjects: nextSubjects,
+				createdAtMs: userRec?.createdAtMs || now,
+				updatedAtMs: now
+			});
+		} else this.userToSubjects.delete(this.userKey(userId));
+		return { ok: true };
+	}
+};
+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(`Identity DO store HTTP ${resp.status}: ${text}`);
+	let json;
+	try {
+		json = text ? JSON.parse(text) : null;
+	} catch {
+		throw new Error(`Identity DO store returned non-JSON response: ${text.slice(0, 200)}`);
+	}
+	if (!isObject(json)) throw new Error("Identity 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 || "Identity DO store error"
+	};
+}
+var KvBackedIdentityStore = class {
+	constructor(prefix) {
+		this.prefix = prefix;
+	}
+	subjectKey(subject) {
+		return `${this.prefix}subject:${subject}`;
+	}
+	userKey(userId) {
+		return `${this.prefix}user:${userId}`;
+	}
+	async getUserIdBySubject(subject) {
+		const s = normalizeOptionalTrimmedString(subject);
+		if (!s) return null;
+		return parseIdentitySubjectRecord(await this.getJson(this.subjectKey(s)))?.userId || null;
+	}
+	async listSubjectsByUserId(userId) {
+		const uid = normalizeOptionalTrimmedString(userId);
+		if (!uid) return [];
+		return parseIdentityUserRecord(await this.getJson(this.userKey(uid)))?.subjects || [];
+	}
+	async linkSubjectToUserId(input) {
+		const userId = normalizeOptionalTrimmedString(input.userId);
+		const subject = normalizeOptionalTrimmedString(input.subject);
+		if (!userId) return {
+			ok: false,
+			code: "invalid_args",
+			message: "Missing userId"
+		};
+		if (!subject) return {
+			ok: false,
+			code: "invalid_args",
+			message: "Missing subject"
+		};
+		const now = Date.now();
+		const existingSubject = parseIdentitySubjectRecord(await this.getJson(this.subjectKey(subject)));
+		if (existingSubject && existingSubject.userId !== userId) {
+			if (!input.allowMoveIfSoleIdentity) return {
+				ok: false,
+				code: "already_linked",
+				message: "Subject is already linked to a different user"
+			};
+			const sourceUser = existingSubject.userId;
+			const sourceUserRec = parseIdentityUserRecord(await this.getJson(this.userKey(sourceUser)));
+			const sourceSubjects = sourceUserRec?.subjects || [];
+			if (sourceSubjects.length !== 1 || sourceSubjects[0] !== subject) return {
+				ok: false,
+				code: "already_linked",
+				message: "Subject is linked to a different user with other identities; merge is not allowed"
+			};
+			const destUserRec = parseIdentityUserRecord(await this.getJson(this.userKey(userId)));
+			const destSubjects = Array.from(new Set([...destUserRec?.subjects || [], subject]));
+			destSubjects.sort();
+			await this.setJson(this.userKey(userId), {
+				version: "identity_user_v1",
+				userId,
+				subjects: destSubjects,
+				createdAtMs: destUserRec?.createdAtMs || now,
+				updatedAtMs: now
+			});
+			await this.setJson(this.userKey(sourceUser), {
+				version: "identity_user_v1",
+				userId: sourceUser,
+				subjects: [],
+				createdAtMs: sourceUserRec?.createdAtMs || existingSubject.createdAtMs || now,
+				updatedAtMs: now
+			});
+			await this.setJson(this.subjectKey(subject), {
+				version: "identity_subject_v1",
+				subject,
+				userId,
+				createdAtMs: existingSubject.createdAtMs || now,
+				updatedAtMs: now
+			});
+			return {
+				ok: true,
+				movedFromUserId: sourceUser
+			};
+		}
+		await this.setJson(this.subjectKey(subject), {
+			version: "identity_subject_v1",
+			subject,
+			userId,
+			createdAtMs: existingSubject?.createdAtMs || now,
+			updatedAtMs: now
+		});
+		const userRec = parseIdentityUserRecord(await this.getJson(this.userKey(userId)));
+		const subjects = Array.from(new Set([...userRec?.subjects || [], subject]));
+		subjects.sort();
+		await this.setJson(this.userKey(userId), {
+			version: "identity_user_v1",
+			userId,
+			subjects,
+			createdAtMs: userRec?.createdAtMs || now,
+			updatedAtMs: now
+		});
+		return { ok: true };
+	}
+	async unlinkSubjectFromUserId(input) {
+		const userId = normalizeOptionalTrimmedString(input.userId);
+		const subject = normalizeOptionalTrimmedString(input.subject);
+		if (!userId) return {
+			ok: false,
+			code: "invalid_args",
+			message: "Missing userId"
+		};
+		if (!subject) return {
+			ok: false,
+			code: "invalid_args",
+			message: "Missing subject"
+		};
+		const subjectRec = parseIdentitySubjectRecord(await this.getJson(this.subjectKey(subject)));
+		if (!subjectRec || subjectRec.userId !== userId) return {
+			ok: false,
+			code: "not_found",
+			message: "Subject is not linked to this user"
+		};
+		const userRec = parseIdentityUserRecord(await this.getJson(this.userKey(userId)));
+		const subjects = userRec?.subjects || [];
+		if (subjects.length <= 1) return {
+			ok: false,
+			code: "cannot_unlink_last_identity",
+			message: "Refusing to remove the last remaining identity"
+		};
+		const nextSubjects = subjects.filter((s) => s !== subject);
+		nextSubjects.sort();
+		await this.setJson(this.userKey(userId), {
+			version: "identity_user_v1",
+			userId,
+			subjects: nextSubjects,
+			createdAtMs: userRec?.createdAtMs || Date.now(),
+			updatedAtMs: Date.now()
+		});
+		await this.del(this.subjectKey(subject));
+		return { ok: true };
+	}
+	async deleteSubjectLinkForDevCleanup(input) {
+		const userId = normalizeOptionalTrimmedString(input.userId);
+		const subject = normalizeOptionalTrimmedString(input.subject);
+		if (!userId) return {
+			ok: false,
+			code: "invalid_args",
+			message: "Missing userId"
+		};
+		if (!subject) return {
+			ok: false,
+			code: "invalid_args",
+			message: "Missing subject"
+		};
+		const subjectRec = parseIdentitySubjectRecord(await this.getJson(this.subjectKey(subject)));
+		if (!subjectRec || subjectRec.userId !== userId) return {
+			ok: false,
+			code: "not_found",
+			message: "Subject is not linked to this user"
+		};
+		const userRec = parseIdentityUserRecord(await this.getJson(this.userKey(userId)));
+		const nextSubjects = (userRec?.subjects || []).filter((s) => s !== subject);
+		if (nextSubjects.length > 0) {
+			nextSubjects.sort();
+			await this.setJson(this.userKey(userId), {
+				version: "identity_user_v1",
+				userId,
+				subjects: nextSubjects,
+				createdAtMs: userRec?.createdAtMs || Date.now(),
+				updatedAtMs: Date.now()
+			});
+		} else await this.del(this.userKey(userId));
+		await this.del(this.subjectKey(subject));
+		return { ok: true };
+	}
+};
+var UpstashRedisRestIdentityStore = class extends KvBackedIdentityStore {
+	constructor(input) {
+		super(input.prefix);
+		this.client = new UpstashRedisRestClient({
+			url: input.url,
+			token: input.token
+		});
+	}
+	getJson(key) {
+		return this.client.getJson(key);
+	}
+	setJson(key, value) {
+		return this.client.setJson(key, value);
+	}
+	del(key) {
+		return this.client.del(key);
+	}
+};
+var RedisTcpIdentityStore = class extends KvBackedIdentityStore {
+	constructor(input) {
+		super(input.prefix);
+		this.client = new RedisTcpClient(input.redisUrl);
+	}
+	getJson(key) {
+		return redisGetJson(this.client, key);
+	}
+	setJson(key, value) {
+		return redisSetJson(this.client, key, value);
+	}
+	del(key) {
+		return redisDel(this.client, key);
+	}
+};
+var CloudflareDurableObjectIdentityStore = class extends KvBackedIdentityStore {
+	constructor(input) {
+		super(input.prefix);
+		this.stub = resolveDoStub({
+			namespace: input.namespace,
+			objectName: input.objectName
+		});
+	}
+	async getJson(key) {
+		const resp = await callDo(this.stub, {
+			op: "get",
+			key
+		});
+		if (!resp.ok) return null;
+		return resp.value;
+	}
+	async setJson(key, value) {
+		const resp = await callDo(this.stub, {
+			op: "set",
+			key,
+			value
+		});
+		if (!resp.ok) throw new Error(resp.message);
+	}
+	async del(key) {
+		const resp = await callDo(this.stub, {
+			op: "del",
+			key
+		});
+		if (!resp.ok) throw new Error(resp.message);
+	}
+};
+function createIdentityStore(input) {
+	const config = isObject(input.config) ? input.config : {};
+	const prefix = resolveIdentityStoreNamespace(config);
+	const kind = normalizeOptionalTrimmedString(config.kind);
+	if (kind === "d1") {
+		const database = resolveD1DatabaseFromConfig(config);
+		if (!database) throw new Error("[identity] D1 identity store selected but no D1 database was provided");
+		input.logger.info("[identity] Using D1 identity store");
+		return new D1IdentityStore({
+			database,
+			...d1ScopeFromConfig({
+				config,
+				namespace: prefix
+			})
+		});
+	}
+	if (kind === "cloudflare-do") {
+		const namespace = resolveDoNamespaceFromConfig(config);
+		if (!namespace) throw new Error("cloudflare-do identity 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("[identity] Using Cloudflare Durable Object identity store");
+		return new CloudflareDurableObjectIdentityStore({
+			namespace,
+			objectName,
+			prefix
+		});
+	}
+	if (kind === "in-memory") {
+		input.logger.info("[identity] Using in-memory identity store (non-persistent)");
+		return new InMemoryIdentityStore(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 identity store enabled but url/token are not both set");
+		input.logger.info("[identity] Using Upstash REST identity store");
+		return new UpstashRedisRestIdentityStore({
+			url,
+			token,
+			prefix
+		});
+	}
+	if (kind === "redis-tcp") {
+		if (!input.isNode) {
+			input.logger.warn("[identity] redis-tcp identity store is not supported in this runtime; falling back to in-memory");
+			return new InMemoryIdentityStore(prefix);
+		}
+		const redisUrl = normalizeOptionalTrimmedString(config.redisUrl) || normalizeOptionalTrimmedString(config.REDIS_URL);
+		if (!redisUrl) throw new Error("redis-tcp identity store enabled but redisUrl is not set");
+		input.logger.info("[identity] Using redis-tcp identity store");
+		return new RedisTcpIdentityStore({
+			redisUrl,
+			prefix
+		});
+	}
+	if (kind) throw new Error(`[identity] Unknown identity 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 identity store enabled but UPSTASH_REDIS_REST_URL / UPSTASH_REDIS_REST_TOKEN are not both set");
+		input.logger.info("[identity] Using Upstash REST identity store");
+		return new UpstashRedisRestIdentityStore({
+			url: upstashUrl,
+			token: upstashToken,
+			prefix
+		});
+	}
+	const redisUrl = normalizeOptionalTrimmedString(config.REDIS_URL);
+	if (redisUrl) {
+		if (!input.isNode) {
+			input.logger.warn("[identity] REDIS_URL is set but TCP Redis is not supported in this runtime; falling back to in-memory");
+			return new InMemoryIdentityStore(prefix);
+		}
+		input.logger.info("[identity] Using redis-tcp identity store");
+		return new RedisTcpIdentityStore({
+			redisUrl,
+			prefix
+		});
+	}
+	input.logger.info("[identity] Using in-memory identity store (non-persistent)");
+	return new InMemoryIdentityStore(prefix);
+}
+//#endregion
+export { D1IdentityStore, IDENTITY_STORE_D1_SCHEMA_SQL, createIdentityStore, ensureIdentityStoreD1Schema, resolveIdentityStoreNamespace };
+
+//# sourceMappingURL=IdentityStore.js.map