@seams/wallet 0.7.3 → 0.8.0

package/dist/esm/react/core/config/configHelpers.js

@@ -1,183 +0,0 @@
-import { normalizeTrimmedString } from "../../shared-ts/src/utils/normalize.js";
-import "../../shared-ts/src/utils/validation.js";
-import { parsePositiveSessionUses } from "../signingEngine/threshold/sessionPolicy.js";
-import { coerceThemeMode } from "../../shared-ts/src/utils/theme.js";
-import { isEvmChainNetwork, isNearChainNetwork, isSeamsChainNetwork, isTempoChainNetwork } from "./chains.js";
-//#region src/core/config/configHelpers.ts
-function resolveIntegerInRange(args) {
-	const candidate = args.value ?? args.fallback;
-	if (typeof candidate !== "number" || !Number.isFinite(candidate) || !Number.isInteger(candidate)) throw new Error(`[configPresets] Invalid config: ${args.path} must be an integer`);
-	if (candidate < args.range.min || candidate > args.range.max) throw new Error(`[configPresets] Invalid config: ${args.path} must be in [${args.range.min}, ${args.range.max}]`);
-	return candidate;
-}
-function resolveOptionalPositiveInteger(args) {
-	const candidate = args.value ?? args.fallback;
-	if (candidate == null) return void 0;
-	if (typeof candidate !== "number" || !Number.isFinite(candidate) || !Number.isInteger(candidate)) throw new Error(`[configPresets] Invalid config: ${args.path} must be an integer`);
-	if (candidate <= 0) throw new Error(`[configPresets] Invalid config: ${args.path} must be > 0`);
-	return candidate;
-}
-function resolveRequiredString(args) {
-	const value = normalizeTrimmedString(args.value) || normalizeTrimmedString(args.fallback);
-	if (!value) throw new Error(`[configPresets] Missing required config: ${args.path}`);
-	return value;
-}
-function resolveBoolean(args) {
-	if (args.value == null) return args.fallback;
-	if (typeof args.value !== "boolean") throw new Error(`[configPresets] Invalid config: ${args.path} must be boolean`);
-	return args.value;
-}
-function toColorTokenRecord(value) {
-	if (!value || typeof value !== "object") return {};
-	const out = {};
-	for (const [k, v] of Object.entries(value)) if (typeof v === "string") out[k] = v;
-	return out;
-}
-function resolveAppearanceThemeId(args) {
-	const id = normalizeTrimmedString(args.value) || args.fallback;
-	if (!id) throw new Error("[configPresets] Invalid config: appearance.theme.id must be non-empty");
-	return id;
-}
-function readLegacyTokenColors(tokens, mode) {
-	if (!tokens || typeof tokens !== "object") return {};
-	const modeRecord = tokens[mode];
-	if (!modeRecord || typeof modeRecord !== "object") return {};
-	return toColorTokenRecord(modeRecord.colors);
-}
-function resolveAppearanceTheme(args) {
-	const fallbackMode = args.fallback.mode;
-	const fallbackShape = args.fallback.shape;
-	const legacyMode = coerceThemeMode(args.value);
-	if (legacyMode) return {
-		id: args.fallback.id,
-		mode: legacyMode,
-		colors: {
-			...args.fallback.colors,
-			...readLegacyTokenColors(args.legacyTokens, legacyMode)
-		},
-		...fallbackShape ? { shape: fallbackShape } : {}
-	};
-	if (args.value == null) return {
-		...args.fallback,
-		colors: {
-			...args.fallback.colors,
-			...readLegacyTokenColors(args.legacyTokens, fallbackMode)
-		}
-	};
-	if (typeof args.value !== "object" || Array.isArray(args.value)) throw new Error("[configPresets] Invalid config: appearance.theme must be an object with id, mode, and optional colors");
-	const record = args.value;
-	const rawMode = record.mode;
-	const mode = rawMode == null ? fallbackMode : coerceThemeMode(rawMode);
-	if (!mode) throw new Error("[configPresets] Invalid config: appearance.theme.mode must be 'light' or 'dark'");
-	const id = resolveAppearanceThemeId({
-		value: record.id,
-		fallback: args.fallback.id
-	});
-	const isThemeSwitch = id !== args.fallback.id;
-	const shape = {
-		...isThemeSwitch ? {} : fallbackShape || {},
-		...toColorTokenRecord(record.shape)
-	};
-	return {
-		id,
-		mode,
-		colors: {
-			...isThemeSwitch ? {} : args.fallback.colors,
-			...readLegacyTokenColors(args.legacyTokens, mode),
-			...toColorTokenRecord(record.colors)
-		},
-		...Object.keys(shape).length > 0 ? { shape } : {}
-	};
-}
-function resolveThemePalette(args) {
-	if (args.value == null) return args.fallback;
-	if (args.value !== "default") throw new Error("[configPresets] Invalid config: appearance.palette must be 'default'");
-	return "default";
-}
-function copyEcdsaSignerProvisioningDefaults(value) {
-	const tempoAllowance = parsePositiveSessionUses(value.tempo.signingSession.remainingUses, "tempo.signingSession.remainingUses");
-	const evmAllowance = parsePositiveSessionUses(value.evm.signingSession.remainingUses, "evm.signingSession.remainingUses");
-	return {
-		tempo: {
-			...value.tempo,
-			signingSession: {
-				...value.tempo.signingSession,
-				remainingUses: tempoAllowance
-			}
-		},
-		evm: {
-			...value.evm,
-			signingSession: {
-				...value.evm.signingSession,
-				remainingUses: evmAllowance
-			}
-		}
-	};
-}
-function resolveChainNetwork(network) {
-	if (!isSeamsChainNetwork(network)) throw new Error(`[configPresets] Invalid chain network: ${String(network || "")}`);
-	return network;
-}
-function resolveChainConfig(args) {
-	const network = resolveChainNetwork(args.input.network);
-	const rpcUrl = resolveRequiredString({
-		value: args.input.rpcUrl,
-		fallback: args.fallback?.rpcUrl,
-		path: `chains.${network}.rpcUrl`
-	});
-	const explorerUrl = resolveRequiredString({
-		value: args.input.explorerUrl,
-		fallback: args.fallback?.explorerUrl,
-		path: `chains.${network}.explorerUrl`
-	});
-	if (isNearChainNetwork(network)) return {
-		network,
-		rpcUrl,
-		explorerUrl
-	};
-	const chainId = resolveOptionalPositiveInteger({
-		value: args.input.chainId,
-		fallback: args.fallback?.chainId,
-		path: `chains.${network}.chainId`
-	});
-	if (typeof chainId !== "number") throw new Error(`[configPresets] Missing required config: chains.${network}.chainId`);
-	if (isTempoChainNetwork(network)) return {
-		network,
-		rpcUrl,
-		explorerUrl,
-		chainId
-	};
-	if (isEvmChainNetwork(network)) return {
-		network,
-		rpcUrl,
-		explorerUrl,
-		chainId
-	};
-	throw new Error(`[configPresets] Unsupported chain network: ${network}`);
-}
-function resolveChains(defaults, overrides) {
-	if (Array.isArray(overrides)) {
-		const defaultsByNetwork = new Map(defaults.map((chain) => [chain.network, { ...chain }]));
-		const byNetwork = /* @__PURE__ */ new Map();
-		const orderedNetworks = [];
-		for (const override of overrides) {
-			const network = resolveChainNetwork(override.network);
-			const resolved = resolveChainConfig({
-				input: override,
-				fallback: defaultsByNetwork.get(network)
-			});
-			byNetwork.set(network, resolved);
-			if (!orderedNetworks.includes(network)) orderedNetworks.push(network);
-		}
-		const resolved = orderedNetworks.map((network) => byNetwork.get(network)).filter((chain) => !!chain);
-		if (!resolved.some((chain) => isNearChainNetwork(chain.network))) throw new Error("[configPresets] Missing required config: chains (at least one near-* network)");
-		return resolved;
-	}
-	const resolved = defaults.map((chain) => ({ ...chain }));
-	if (!resolved.some((chain) => isNearChainNetwork(chain.network))) throw new Error("[configPresets] Missing required config: chains (at least one near-* network)");
-	return resolved;
-}
-//#endregion
-export { copyEcdsaSignerProvisioningDefaults, resolveAppearanceTheme, resolveBoolean, resolveChains, resolveIntegerInRange, resolveThemePalette };
-
-//# sourceMappingURL=configHelpers.js.map

package/dist/esm/react/core/config/defaultConfigs.js

@@ -1,120 +0,0 @@
-import { UserVerificationPolicy } from "../../shared-ts/src/utils/authenticatorOptions.js";
-import "../../shared-ts/src/threshold/participants.js";
-import { DEFAULT_THRESHOLD_SESSION_TTL_MS } from "../signingEngine/threshold/sessionPolicy.js";
-import { buildConfigsFromDefaults } from "./configBuilder.js";
-//#region src/core/config/defaultConfigs.ts
-const DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY = {
-	enabled: true,
-	targetDepth: 5,
-	lowWatermark: 4,
-	maxRefillInFlight: 1,
-	refillAttemptTimeoutMs: 3e4
-};
-const PASSKEY_MANAGER_DEFAULT_CONFIGS = {
-	network: {
-		chains: [
-			{
-				network: "near-testnet",
-				rpcUrl: "https://rpc.testnet.fastnear.com",
-				explorerUrl: "https://testnet.nearblocks.io"
-			},
-			{
-				network: "tempo-testnet",
-				rpcUrl: "https://rpc.moderato.tempo.xyz",
-				explorerUrl: "https://explore.tempo.xyz",
-				chainId: 42431
-			},
-			{
-				network: "arc-testnet",
-				rpcUrl: "https://rpc.testnet.arc.network",
-				explorerUrl: "https://testnet.arcscan.app",
-				chainId: 5042002
-			},
-			{
-				network: "ethereum-sepolia",
-				rpcUrl: "https://ethereum-sepolia-rpc.publicnode.com",
-				explorerUrl: "https://sepolia.etherscan.io",
-				chainId: 11155111
-			}
-		],
-		relayer: {
-			accountId: "",
-			url: "",
-			routes: { delegateAction: "/signed-delegate" }
-		}
-	},
-	registration: {
-		mode: "managed",
-		projectEnvironmentId: "",
-		publishableKey: "",
-		paymentMode: "disabled",
-		nearAccountProvisioning: { kind: "implicit_account" }
-	},
-	signing: {
-		sessionDefaults: {
-			ttlMs: DEFAULT_THRESHOLD_SESSION_TTL_MS,
-			remainingUses: 3
-		},
-		emailOtp: { authPolicy: "session" },
-		sessionPersistenceMode: "none",
-		sessionSeal: { mode: "none" },
-		routerAb: { normalSigning: { mode: "disabled" } },
-		routerAbEcdsaDerivation: { presignaturePool: DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY },
-		thresholdEcdsa: { provisioningDefaults: {
-			tempo: {
-				enabled: true,
-				signingSession: {
-					kind: "jwt",
-					ttlMs: DEFAULT_THRESHOLD_SESSION_TTL_MS,
-					remainingUses: 3
-				}
-			},
-			evm: {
-				enabled: true,
-				signingSession: {
-					kind: "jwt",
-					ttlMs: DEFAULT_THRESHOLD_SESSION_TTL_MS,
-					remainingUses: 3
-				}
-			}
-		} }
-	},
-	wallet: {
-		mode: "direct",
-		iframe: {
-			origin: "https://wallet.example.localhost",
-			servicePath: "/wallet-service",
-			sdkBasePath: "/sdk",
-			walletHostVariant: "runtime",
-			rpIdOverride: "example.localhost"
-		}
-	},
-	webauthn: { authenticatorOptions: {
-		userVerification: UserVerificationPolicy.Preferred,
-		originPolicy: {
-			single: void 0,
-			all_subdomains: true,
-			multiple: void 0
-		}
-	} },
-	ui: { appearance: {
-		theme: {
-			id: "default",
-			mode: "dark",
-			colors: {}
-		},
-		palette: "default"
-	} }
-};
-function buildConfigsFromEnv(overrides = {}, options) {
-	return buildConfigsFromDefaults({
-		defaults: PASSKEY_MANAGER_DEFAULT_CONFIGS,
-		overrides,
-		fallbackRouterAbEcdsaDerivationPresignaturePoolPolicy: DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY,
-		options
-	});
-}
-//#endregion
-export { DEFAULT_ROUTER_AB_ECDSA_DERIVATION_PRESIGNATURE_POOL_POLICY, PASSKEY_MANAGER_DEFAULT_CONFIGS, buildConfigsFromEnv };
-
-//# sourceMappingURL=defaultConfigs.js.map

package/dist/esm/react/core/config/defineConfig.js

@@ -1,48 +0,0 @@
-//#region src/core/config/defineConfig.ts
-/**
-* Builds a `SeamsConfigsInput` from the values an application actually has to
-* supply. Everything else — wallet service path, SDK base path, relayer
-* account, chain RPC and explorer URLs — comes from the SDK defaults.
-*
-* @example
-* const config = defineSeamsConfig({
-*   walletOrigin: import.meta.env.VITE_WALLET_ORIGIN,
-*   relayerUrl: import.meta.env.VITE_RELAYER_URL,
-*   publishableKey: import.meta.env.VITE_SEAMS_PUBLISHABLE_KEY,
-* });
-*/
-function defineSeamsConfig(input) {
-	const { walletOrigin, relayerUrl, projectEnvironmentId, publishableKey, ...rest } = input;
-	return {
-		...rest,
-		iframeWallet: {
-			...input.iframeWallet,
-			walletOrigin
-		},
-		relayer: {
-			...input.relayer,
-			url: relayerUrl
-		},
-		registration: {
-			mode: "managed",
-			...input.registration,
-			...projectEnvironmentId ? { projectEnvironmentId } : {},
-			publishableKey
-		}
-	};
-}
-const TESTNET_NETWORKS = ["near-testnet", "tempo-testnet"];
-/**
-* `defineSeamsConfig` pinned to the NEAR and Tempo testnets — the pair the
-* getting-started guide signs on. Pass `chains` to configure a different set.
-*/
-function seamsTestnetConfig(input) {
-	return defineSeamsConfig({
-		chains: TESTNET_NETWORKS.map((network) => ({ network })),
-		...input
-	});
-}
-//#endregion
-export { defineSeamsConfig, seamsTestnetConfig };
-
-//# sourceMappingURL=defineConfig.js.map

package/dist/esm/react/core/config/managedRuntimeScope.js

@@ -1,16 +0,0 @@
-//#region src/core/config/managedRuntimeScope.ts
-function resolveManagedRuntimeScopeBootstrap(configs) {
-	const registration = configs.registration;
-	if (registration.mode !== "managed") return void 0;
-	const projectEnvironmentId = String(registration.projectEnvironmentId || "").trim();
-	const publishableKey = String(registration.publishableKey || "").trim();
-	if (!projectEnvironmentId || !publishableKey) return void 0;
-	return {
-		projectEnvironmentId,
-		publishableKey
-	};
-}
-//#endregion
-export { resolveManagedRuntimeScopeBootstrap };
-
-//# sourceMappingURL=managedRuntimeScope.js.map

package/dist/esm/react/core/indexedDB/accountKeyMaterial.js

@@ -1,68 +0,0 @@
-import { normalizeTrimmedString } from "../../shared-ts/src/utils/normalize.js";
-import "../../shared-ts/src/utils/validation.js";
-import { resolveProfileAccountContextFromCandidates } from "./profileAccountProjection.js";
-//#region src/core/indexedDB/accountKeyMaterial.ts
-async function resolveAccountKeyMaterialTarget(clientDB, input) {
-	const explicitProfileId = normalizeTrimmedString(input.explicitProfileId || "");
-	const explicitChainIdKey = normalizeTrimmedString(input.explicitChainIdKey || "").toLowerCase();
-	const explicitAccountAddress = normalizeTrimmedString(input.explicitAccountAddress || "").toLowerCase();
-	if (explicitProfileId || explicitChainIdKey || explicitAccountAddress) {
-		if (!explicitProfileId || !explicitChainIdKey || !explicitAccountAddress) throw new Error("IndexedDBManager: profileId, chainIdKey, and accountAddress are required for explicit key target writes");
-		const matchingExplicitRef = input.accountRefs.find((accountRef) => normalizeTrimmedString(accountRef.chainIdKey || "").toLowerCase() === explicitChainIdKey);
-		if (matchingExplicitRef) {
-			const mapped = await clientDB.resolveProfileAccountContext(matchingExplicitRef).catch(() => null);
-			if (mapped?.profileId && String(mapped.profileId).trim() !== explicitProfileId) throw new Error(`IndexedDBManager: Explicit key target (${explicitProfileId}, ${explicitChainIdKey}, ${matchingExplicitRef.accountAddress}) mismatches mapped profile ${String(mapped.profileId).trim()}`);
-		}
-		return {
-			profileId: explicitProfileId,
-			chainIdKey: explicitChainIdKey,
-			accountAddress: explicitAccountAddress
-		};
-	}
-	const resolved = await resolveProfileAccountContextFromCandidates(clientDB, input.accountRefs);
-	if (!resolved?.profileId) return null;
-	return {
-		profileId: resolved.profileId,
-		chainIdKey: resolved.accountRef.chainIdKey,
-		accountAddress: resolved.accountRef.accountAddress
-	};
-}
-async function getAccountKeyMaterial(args) {
-	const target = await resolveAccountKeyMaterialTarget(args.deps.clientDB, { accountRefs: args.accountRefs });
-	if (!target?.profileId || !target.chainIdKey) return null;
-	return args.deps.keyMaterialStore.getKeyMaterial(target.profileId, args.signerSlot, target.chainIdKey, args.keyKind);
-}
-async function storeAccountKeyMaterial(deps, input) {
-	if (!Number.isSafeInteger(input.signerSlot) || input.signerSlot < 1) throw new Error("IndexedDBManager: Invalid signerSlot for key write");
-	const keyKind = normalizeTrimmedString(input.keyKind || "");
-	if (!keyKind) throw new Error("IndexedDBManager: Missing keyKind for key write");
-	const algorithm = normalizeTrimmedString(input.algorithm || "").toLowerCase();
-	if (!algorithm) throw new Error("IndexedDBManager: Missing algorithm for key write");
-	const publicKey = normalizeTrimmedString(input.publicKey || "");
-	if (!publicKey) throw new Error("IndexedDBManager: Missing publicKey for key write");
-	const signerId = normalizeTrimmedString(input.signerId || "");
-	if (!signerId) throw new Error("IndexedDBManager: Missing signerId for key write");
-	const target = await resolveAccountKeyMaterialTarget(deps.clientDB, input);
-	if (!target?.profileId || !target.chainIdKey || !target.accountAddress) throw new Error("IndexedDBManager: Missing profile/account mapping for key write. Persist profile/account first or pass explicit profileId + chainIdKey.");
-	const schemaVersion = Number.isSafeInteger(input.schemaVersion) && typeof input.schemaVersion === "number" && input.schemaVersion >= 1 ? input.schemaVersion : 1;
-	const record = {
-		profileId: target.profileId,
-		signerSlot: input.signerSlot,
-		chainIdKey: target.chainIdKey,
-		accountAddress: target.accountAddress,
-		keyKind,
-		algorithm,
-		publicKey,
-		signerId,
-		timestamp: typeof input.timestamp === "number" ? input.timestamp : Date.now(),
-		schemaVersion
-	};
-	const wrapKeySalt = normalizeTrimmedString(input.wrapKeySalt || "");
-	if (wrapKeySalt) record.wrapKeySalt = wrapKeySalt;
-	if (input.payload) record.payload = input.payload;
-	await deps.keyMaterialStore.storeKeyMaterial(record);
-}
-//#endregion
-export { getAccountKeyMaterial, resolveAccountKeyMaterialTarget, storeAccountKeyMaterial };
-
-//# sourceMappingURL=accountKeyMaterial.js.map

package/dist/esm/react/core/indexedDB/accountSignerLifecycle.js

@@ -1,143 +0,0 @@
-import { normalizeFiniteNumber, normalizeTrimmedString } from "../../shared-ts/src/utils/normalize.js";
-import "../../shared-ts/src/utils/index.js";
-//#region src/core/indexedDB/accountSignerLifecycle.ts
-const SIGNER_MATERIAL_FINGERPRINT_METADATA_KEY = "signerMaterialFingerprint";
-var SignerLifecycleError = class extends Error {
-	constructor(args) {
-		super(args.message);
-		this.name = "SignerLifecycleError";
-		this.code = args.code;
-		this.details = args.details || {};
-	}
-};
-function normalizeNonEmpty(value, label) {
-	const normalized = normalizeTrimmedString(value);
-	if (!normalized) throw new SignerLifecycleError({
-		code: "signer_lifecycle_invalid_input",
-		message: `${label} is required`,
-		details: { label }
-	});
-	return normalized;
-}
-function normalizeOptionalPositiveInteger(value, label) {
-	if (value == null) return void 0;
-	const normalized = normalizeFiniteNumber(value);
-	if (normalized == null || !Number.isSafeInteger(normalized) || normalized < 1) throw new SignerLifecycleError({
-		code: "signer_lifecycle_invalid_input",
-		message: `${label} must be an integer >= 1`,
-		details: {
-			label,
-			value
-		}
-	});
-	return normalized;
-}
-function normalizeSessionStatusRequiredPositiveInteger(value, label) {
-	const normalized = normalizeOptionalPositiveInteger(value, label);
-	if (normalized == null) throw new SignerLifecycleError({
-		code: "signer_lifecycle_invalid_input",
-		message: `${label} is required`,
-		details: { label }
-	});
-	return normalized;
-}
-function firstFreeSlot(reservedSlots) {
-	for (let slot = 1; slot < 1e3; slot += 1) if (!reservedSlots.has(slot)) return slot;
-	throw new SignerLifecycleError({
-		code: "signer_lifecycle_no_available_slot",
-		message: "No available account signer slot"
-	});
-}
-function getSignerMaterialFingerprint(signer) {
-	const value = signer.metadata?.[SIGNER_MATERIAL_FINGERPRINT_METADATA_KEY];
-	return typeof value === "string" ? value.trim() : "";
-}
-function assertExistingSignerMaterialMatches(args) {
-	const expectedFingerprint = normalizeNonEmpty(args.expectedFingerprint, "activationPolicy.materialFingerprint");
-	const existingFingerprint = getSignerMaterialFingerprint(args.existingSigner);
-	if (!existingFingerprint) throw new SignerLifecycleError({
-		code: "signer_lifecycle_missing_material_fingerprint",
-		message: `Existing signer ${args.existingSigner.signerId} is missing signer material fingerprint`,
-		details: { signerId: args.existingSigner.signerId }
-	});
-	if (existingFingerprint !== expectedFingerprint) throw new SignerLifecycleError({
-		code: "signer_lifecycle_material_mismatch",
-		message: `Existing signer material mismatch for ${args.existingSigner.signerId}`,
-		details: {
-			signerId: args.existingSigner.signerId,
-			expectedFingerprint,
-			existingFingerprint
-		}
-	});
-}
-function planAccountSignerActivation(input) {
-	const signerId = normalizeNonEmpty(input.signer.signerId, "signerId");
-	const signerKind = normalizeNonEmpty(input.signer.signerKind, "signerKind");
-	normalizeNonEmpty(input.signer.signerAuthMethod, "signerAuthMethod");
-	normalizeNonEmpty(input.signer.signerSource, "signerSource");
-	const activeSigners = Array.isArray(input.activeSigners) ? input.activeSigners : [];
-	const existingSigner = activeSigners.find((signer) => signer.signerId === signerId);
-	const preferredSlot = normalizeOptionalPositiveInteger(input.preferredSlot, "preferredSlot");
-	if (input.activationPolicy.mode === "reuse_existing") {
-		normalizeNonEmpty(input.activationPolicy.signerId, "activationPolicy.signerId");
-		if (input.activationPolicy.signerId !== signerId) throw new SignerLifecycleError({
-			code: "signer_lifecycle_invalid_input",
-			message: "reuse_existing activation policy signerId must match signer.signerId",
-			details: {
-				policySignerId: input.activationPolicy.signerId,
-				signerId
-			}
-		});
-		normalizeNonEmpty(input.activationPolicy.materialFingerprint, "activationPolicy.materialFingerprint");
-	}
-	if (input.activationPolicy.mode === "replace_slot" || input.activationPolicy.mode === "replace_profile_chain_kind") {
-		if (input.activationPolicy.replacedSignerKind !== signerKind) throw new SignerLifecycleError({
-			code: "signer_lifecycle_invalid_input",
-			message: "replacement activation policy signer kind must match signer.signerKind",
-			details: {
-				signerKind,
-				replacedSignerKind: input.activationPolicy.replacedSignerKind
-			}
-		});
-		normalizeNonEmpty(input.activationPolicy.revocationReason, "activationPolicy.revocationReason");
-	}
-	if (existingSigner) {
-		if (input.activationPolicy.mode === "reuse_existing") assertExistingSignerMaterialMatches({
-			existingSigner,
-			expectedFingerprint: input.activationPolicy.materialFingerprint
-		});
-		return { signerSlot: normalizeSessionStatusRequiredPositiveInteger(existingSigner.signerSlot, "signerSlot") };
-	}
-	if (input.activationPolicy.mode === "reuse_existing") {
-		const conflictingSigner = activeSigners.find((signer) => signer.signerKind === signerKind);
-		if (conflictingSigner) throw new SignerLifecycleError({
-			code: "signer_lifecycle_duplicate_registration",
-			message: `Duplicate account registration for ${signerKind}: existing signer ${conflictingSigner.signerId} differs from ${signerId}`,
-			details: {
-				signerKind,
-				signerId,
-				conflictingSignerId: conflictingSigner.signerId
-			}
-		});
-	}
-	if (input.activationPolicy.mode === "fail_if_occupied") {
-		const signerSlot = normalizeSessionStatusRequiredPositiveInteger(input.activationPolicy.signerSlot, "signerSlot");
-		const occupant = activeSigners.find((signer) => signer.signerSlot === signerSlot);
-		if (occupant) throw new SignerLifecycleError({
-			code: "signer_lifecycle_slot_occupied",
-			message: `Active signer slot ${signerSlot} is already occupied`,
-			details: {
-				signerSlot,
-				occupantSignerId: occupant.signerId
-			}
-		});
-		return { signerSlot };
-	}
-	if (input.activationPolicy.mode === "replace_slot" || input.activationPolicy.mode === "replace_profile_chain_kind") return { signerSlot: normalizeSessionStatusRequiredPositiveInteger(input.activationPolicy.signerSlot, "signerSlot") };
-	const reservedSlots = new Set(activeSigners.map((signer) => signer.signerSlot));
-	return { signerSlot: preferredSlot && !reservedSlots.has(preferredSlot) ? preferredSlot : firstFreeSlot(reservedSlots) };
-}
-//#endregion
-export { SIGNER_MATERIAL_FINGERPRINT_METADATA_KEY, SignerLifecycleError, planAccountSignerActivation };
-
-//# sourceMappingURL=accountSignerLifecycle.js.map

package/dist/esm/react/core/indexedDB/index.js

@@ -1,60 +0,0 @@
-import { SEAMS_WALLET_DB_NAME } from "./schemaNames.js";
-import "./seamsWalletDB/schema.js";
-import "./seamsWalletDB/manager.js";
-import { seamsWalletDB } from "./singletons.js";
-import "./accountSignerLifecycle.js";
-import "./pendingWalletRegistrationCommit.js";
-import "./pendingWalletRecoveryCommit.js";
-import "./seamsWalletDB/walletSessionAuthorizationStore.js";
-import "./seamsWalletDB/repositories.js";
-import { UnifiedIndexedDBManager } from "./unifiedIndexedDBManager.js";
-import "./nonceLaneCoordinationStore.js";
-//#region src/core/indexedDB/index.ts
-const DB_CONFIG_BY_MODE = {
-	app: {
-		walletDbName: SEAMS_WALLET_DB_NAME,
-		disabled: false
-	},
-	wallet: {
-		walletDbName: SEAMS_WALLET_DB_NAME,
-		disabled: false
-	},
-	disabled: {
-		walletDbName: SEAMS_WALLET_DB_NAME,
-		disabled: true
-	}
-};
-let configured = null;
-/**
-* Configure IndexedDB database names for the current runtime.
-*
-* Call this once, early (before any IndexedDB access).
-* - Wallet iframe host should use `mode: 'wallet'`.
-* - App origin should use `mode: 'disabled'` when wallet-iframe mode is enabled.
-* - Non-iframe apps should use `mode: 'app'`.
-* - Headless/proxy runtimes that cannot touch IndexedDB should use `mode: 'disabled'`.
-*/
-function configureIndexedDB(args) {
-	const mode = args?.mode;
-	const next = DB_CONFIG_BY_MODE[mode];
-	if (!next) throw new Error(`[IndexedDBManager] Unknown IndexedDBMode: ${String(mode)}`);
-	if (configured) {
-		if (!(configured.walletDbName === next.walletDbName && configured.disabled === next.disabled)) console.warn("[IndexedDBManager] configureIndexedDB called multiple times; ignoring subsequent configuration", {
-			configured,
-			requested: next
-		});
-		return { walletDbName: configured.walletDbName };
-	}
-	configured = {
-		mode,
-		...next
-	};
-	seamsWalletDB.setDbName(next.walletDbName);
-	seamsWalletDB.setDisabled(next.disabled);
-	return { walletDbName: configured.walletDbName };
-}
-const IndexedDBManager = new UnifiedIndexedDBManager({ seamsWalletDB });
-//#endregion
-export { IndexedDBManager, configureIndexedDB };
-
-//# sourceMappingURL=index.js.map