@glyphteck/veyl 0.63.7 → 0.65.0

package/dist/accountprofiles.js

@@ -0,0 +1,1362 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// ../../core/config.js
+var MS_PER_SECOND = 1000;
+var MINUTE_MS = 60 * MS_PER_SECOND;
+var HOUR_MS = 60 * MINUTE_MS;
+var DAY_MS = 24 * HOUR_MS;
+var KIB_BYTES = 1024;
+var MIB_BYTES = 1024 * 1024;
+var SATS_PER_BITCOIN = 100000000n;
+var USERNAME_MAX_CHARS = 12;
+var PASSWORD_MIN_CHARS = 15;
+var PASSWORD_MAX_CHARS = 64;
+var PASSWORD_MAX_BYTES = 4 * 1024;
+var LOCAL_MEDIA_CACHE_MAX_BYTES = 512 * MIB_BYTES;
+var LOCAL_PROFILE_CACHE_MAX_ITEMS = 500;
+var LOCAL_PROFILE_CACHE_MAX_AGE_MS = 30 * DAY_MS;
+var LOCAL_CHAT_CACHE_MAX_ITEMS = 1000;
+var LOCAL_CHAT_MESSAGE_CACHE_MAX_VISIBLE = 1000;
+var LOCAL_AVATAR_CACHE_MAX_BYTES = 128 * MIB_BYTES;
+var LOCAL_AVATAR_CACHE_MAX_AGE_MS = 30 * DAY_MS;
+var AVATAR_IMAGE_MAX_BYTES = 256 * KIB_BYTES;
+var AVATAR_IMAGE_QUALITY_ATTEMPTS = Object.freeze([0.92, 0.84, 0.76, 0.68]);
+var CHAT_AVATAR_IMAGE_MAX_BYTES = AVATAR_IMAGE_MAX_BYTES;
+var CHAT_AVATAR_REF_MAX_CHARS = 256;
+var CHAT_MESSAGE_FILE_CACHE_MAX_BYTES = 64 * MIB_BYTES;
+var IDLE_CALLBACK_MIN_TIMEOUT_MS = 50;
+var ATTACHMENT_CACHE_IDLE_TIMEOUT_MS = 2500;
+var ATTACHMENT_CACHE_FALLBACK_DELAY_MS = 250;
+var CHAT_UNSAVED_TTL_DAYS = 21;
+var CHAT_UNSAVED_TTL_MS = CHAT_UNSAVED_TTL_DAYS * DAY_MS;
+var CHAT_AFTER_SEEN_MS = DAY_MS;
+var CHAT_MEDIA_TTL_DAYS = CHAT_UNSAVED_TTL_DAYS;
+var CHAT_MEDIA_TTL_MS = CHAT_MEDIA_TTL_DAYS * DAY_MS;
+var CHAT_UPLOAD_MAX_BYTES = 64 * MIB_BYTES;
+var CHAT_AUDIO_TRANSCODE_BITRATE_BPS = 128000;
+var CHAT_VIDEO_TRANSCODE_VIDEO_BITRATE_BPS = 3000000;
+var CHAT_VIDEO_TRANSCODE_AUDIO_BITRATE_BPS = CHAT_AUDIO_TRANSCODE_BITRATE_BPS;
+var CHAT_MESSAGE_BATCH_SIZE = 40;
+var CHAT_MESSAGE_QUERY_MAX_DOCS = 120;
+var CHAT_MESSAGE_MUTATION_MAX_ITEMS = 256;
+var CHAT_TTL_CLIENT_DELETE_GRACE_MS = MINUTE_MS;
+var CHAT_BATCH_CLEANUP_IDLE_TIMEOUT_MS = 1500;
+var CHAT_BATCH_CLEANUP_IDLE_DELAY_MS = 250;
+var CHAT_LIST_PAGE_SIZE = 20;
+var CHAT_LIST_LIVE_COUNT = CHAT_LIST_PAGE_SIZE;
+var CHAT_INBOX_CURSOR_OVERLAP_MS = 5 * MS_PER_SECOND;
+var CHAT_LIST_CACHE_WRITE_DELAY_MS = 1500;
+var CHAT_LIST_SNAPSHOT_COALESCE_MS = 80;
+var CHAT_LIST_LISTENER_RETRY_MS = 1000;
+var CHAT_TOP_WARM_COUNT = 0;
+var CHAT_EAGER_WARM_COUNT = 0;
+var CHAT_WARM_DELAY_MS = 3000;
+var CHAT_WARM_BATCH_SIZE = CHAT_MESSAGE_BATCH_SIZE;
+var CHAT_MESSAGE_VIEW_CACHE_SIZE = 30;
+var CHAT_MEDIA_WARM_MESSAGES_PER_CHAT = CHAT_MESSAGE_BATCH_SIZE;
+var CHAT_MEDIA_WARM_START_DELAY_MS = 600;
+var CHAT_MEDIA_WARM_STEP_DELAY_MS = 120;
+var CHAT_MEDIA_WARM_TYPES = Object.freeze(["img", "gif", "mp4"]);
+var CHAT_MEDIA_WARM_MAX_BYTES = 0;
+var CHAT_READ_WRITE_INTERVAL_MS = 2 * MS_PER_SECOND;
+var CHAT_READ_WRITE_MAX_WAIT_MS = 8 * MS_PER_SECOND;
+var CHAT_LIVE_PING_INTERVAL_MS = 5 * MS_PER_SECOND;
+var CHAT_LIVE_SWEEP_INTERVAL_MS = 15 * MS_PER_SECOND;
+var CHAT_LIVE_STALE_AFTER_MS = 15 * MS_PER_SECOND;
+var CHAT_LIVE_RECONNECT_MAX_MS = 5 * MS_PER_SECOND;
+var CHAT_LIVE_TYPING_IDLE_MS = 8 * MS_PER_SECOND;
+var CHAT_LIVE_TYPING_RENEW_MS = 5 * MS_PER_SECOND;
+var CHAT_LIVE_COMPOSITION_HANDOFF_MS = 15 * MS_PER_SECOND;
+var CHAT_LIVE_READ_SEND_INTERVAL_MS = 120;
+var CHAT_LIVE_READ_SEND_MAX_WAIT_MS = 500;
+var CHAT_LIVE_READ_WRITE_INTERVAL_MS = 12 * MS_PER_SECOND;
+var CHAT_LIVE_READ_WRITE_MAX_WAIT_MS = 30 * MS_PER_SECOND;
+var CHAT_SEND_QUEUE_RATE_LIMIT_COUNT = 12;
+var CHAT_SEND_QUEUE_RATE_LIMIT_WINDOW_MS = 10 * MS_PER_SECOND;
+var CHAT_SETTINGS_BODY_MAX_BYTES = 32 * KIB_BYTES;
+var CHAT_MANIFEST_MAX_BYTES = 256 * KIB_BYTES;
+var CHAT_RECEIPT_MAX_MEMBERS = 32;
+var CHAT_ORDINARY_DELIVERY_MAX_MEMBERS = 128;
+var CHAT_MAX_MEMBERS = 256;
+var CHAT_MAX_TEXT_CHARS = 2048;
+var CHAT_TITLE_MAX_CHARS = 16;
+var CHAT_MAX_REACTIONS = CHAT_MAX_MEMBERS;
+var SEARCH_DEBOUNCE_MS = 300;
+var RECENT_PEER_REFRESH_LIMIT = 50;
+var RECENT_PEER_REFRESH_DELAY_MS = 250;
+var RECENT_PEER_REFRESH_INTERVAL_MS = 5 * MINUTE_MS;
+var RECENT_PEER_REFRESH_THROTTLE_MS = 120;
+var BAN_REFRESH_GRACE_MS = 50;
+var REQUEST_MONEY_MAX_SATS = SATS_PER_BITCOIN * 100000n;
+var WALLET_TRANSFER_POLL_MS = 3 * MS_PER_SECOND;
+var WALLET_ACTIVE_TRANSFER_REFRESH_MS = MS_PER_SECOND;
+var WALLET_IDLE_ACTIVE_TRANSFER_REFRESH_MS = 5 * MS_PER_SECOND;
+var WALLET_VISIBLE_TRANSFER_DISCOVERY_WINDOW_MS = 12 * MS_PER_SECOND;
+var WALLET_ACTIVE_TRANSFER_EMPTY_SCAN_LIMIT = 8;
+var WALLET_CACHE_HYDRATE_DELAY_MS = 0;
+var WALLET_BOOT_REFRESH_DELAY_MS = 500;
+var WALLET_BOOT_CACHED_REFRESH_DELAY_MS = 2500;
+var WALLET_REGTEST_DEPOSIT_CLAIM_POLL_MS = 20 * MS_PER_SECOND;
+var WALLET_MAINNET_DEPOSIT_CLAIM_POLL_MS = MINUTE_MS;
+var WALLET_BALANCE_EVENT_COALESCE_MS = 2 * MS_PER_SECOND;
+var WALLET_INCOMING_UPDATE_COALESCE_MS = 250;
+var WALLET_AUTO_CLAIM_MAX_FEE_SATS = 5000;
+var WALLET_CLAIM_PAGE_SIZE = 100;
+var WALLET_PENDING_TRANSFER_CLAIM_BATCH_SIZE = 50;
+var WALLET_PENDING_TRANSFER_STATUS_BATCH_SIZE = 2;
+var WALLET_PENDING_TRANSFER_COLD_REFRESH_BATCH_SIZE = 50;
+var WALLET_PENDING_TRANSFER_COLD_REFRESH_INTERVAL_MS = 15 * MS_PER_SECOND;
+var WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_SMALL_QUEUE = 3;
+var WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_LARGE_QUEUE = 10;
+var WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_SMALL_SIZE = 2;
+var WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_LARGE_SIZE = 3;
+var WALLET_PENDING_TRANSFER_SLOW_CLAIM_MS = 4 * MS_PER_SECOND;
+var WALLET_PENDING_TRANSFER_CLAIM_COOLDOWN_MS = 15 * MS_PER_SECOND;
+var WALLET_SDK_BACKGROUND_QUIET_MS = MS_PER_SECOND;
+var WALLET_RECENT_TRANSFER_LIMIT = 100;
+var WALLET_TRANSFER_PAGE_LIMIT = 100;
+var WALLET_TRANSFER_FETCH_THROTTLE_MS = 150;
+var WALLET_PENDING_TRANSFER_CLAIM_RETRY_MS = 3 * MS_PER_SECOND;
+var WALLET_SENT_TRANSFER_REFRESH_DELAY_MS = 3 * MS_PER_SECOND;
+var WALLET_PENDING_TRANSFER_BOOT_GRACE_MS = 15 * MS_PER_SECOND;
+var WALLET_PENDING_TRANSFER_HOT_AGE_MS = MINUTE_MS;
+var WALLET_PENDING_TRANSFER_WARM_AGE_MS = 10 * MINUTE_MS;
+var WALLET_PENDING_TRANSFER_WARM_RETRY_MS = 15 * MS_PER_SECOND;
+var WALLET_PENDING_TRANSFER_STALE_RETRY_MS = 2 * MINUTE_MS;
+var WALLET_PENDING_TRANSFER_STUCK_RETRY_MS = 10 * MINUTE_MS;
+var WALLET_PENDING_TRANSFER_DORMANT_RETRY_MS = HOUR_MS;
+var WALLET_TRANSFER_CACHE_WRITE_DELAY_MS = 3 * MS_PER_SECOND;
+
+// ../../core/utils/text.js
+function cleanText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function lowerText(value) {
+  return cleanText(value).toLowerCase();
+}
+function sameText(left, right) {
+  return lowerText(left) === lowerText(right);
+}
+
+// ../../core/avatar.js
+var AVATAR_VERSION_RE = /^[0-9a-f]{64}$/;
+function readAvatarVersion(value) {
+  const version = typeof value === "string" ? value.trim().toLowerCase() : "";
+  return AVATAR_VERSION_RE.test(version) ? version : null;
+}
+function cleanAvatarUsername(value) {
+  return cleanText(value).replace(/^@+/, "").slice(0, 40);
+}
+
+// ../../core/crypto/core.js
+"use client";
+var encoder = new TextEncoder;
+var decoder = new TextDecoder;
+var MEM_KIB = 32 * 1024;
+function randomBytes(length) {
+  const out = new Uint8Array(length);
+  if (globalThis.crypto?.getRandomValues) {
+    globalThis.crypto.getRandomValues(out);
+    return out;
+  }
+  throw new Error("crypto.getRandomValues is not available in this environment");
+}
+function toBytes(value, label = "bytes") {
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return encoder.encode(value);
+  }
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  throw new Error(`Invalid ${label}`);
+}
+function toBytes32(k, label = "key") {
+  if (k instanceof Uint8Array) {
+    if (k.length !== 32)
+      throw new Error(`Invalid ${label} key length`);
+    return k;
+  }
+  if (typeof k === "string") {
+    return fromHex(k, label);
+  }
+  throw new Error(`${label} key must be Uint8Array or 64-char hex`);
+}
+function toHex(value) {
+  return Array.from(toBytes(value)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function fromHexBytes(hex, label = "hex") {
+  if (typeof hex !== "string" || hex.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(hex)) {
+    throw new Error(`Invalid ${label} hex`);
+  }
+  const out = new Uint8Array(hex.length / 2);
+  for (let i = 0;i < out.length; i += 1) {
+    out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+function fromHex(hex, label = "hex") {
+  const bytes = fromHexBytes(hex, label);
+  if (bytes.length !== 32) {
+    throw new Error(`Invalid ${label} hex`);
+  }
+  return bytes;
+}
+function cleanBytes(...values) {
+  for (const value of values) {
+    try {
+      value?.fill?.(0);
+    } catch {}
+  }
+}
+
+// ../../core/account/profiles.js
+var ACCOUNT_PROFILES_VERSION = 1;
+var PROFILE_ID_RE = /^[0-9a-f]{32}$/;
+var REGISTRY_FIELDS = new Set(["version", "environment", "selectedProfileId", "profiles"]);
+var PROFILE_FIELDS = new Set([
+  "profileId",
+  "environment",
+  "uid",
+  "username",
+  "avatarVersion",
+  "createdAt",
+  "lastUsedAt"
+]);
+var INPUT_FIELDS = new Set(["environment", "uid", "username", "avatarVersion"]);
+var PRESENTATION_FIELDS = new Set(["username", "avatarVersion"]);
+function requireRecord(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} required`);
+  }
+  return value;
+}
+function requireFields(value, allowed, label) {
+  requireRecord(value, label);
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key))
+      throw new Error(`${label} field not allowed: ${key}`);
+  }
+  return value;
+}
+function requireEnvironment(value) {
+  const environment = lowerText(value);
+  if (!environment)
+    throw new Error("account profile environment required");
+  return environment;
+}
+function requireUid(value) {
+  const uid = cleanText(value);
+  if (!uid)
+    throw new Error("account profile uid required");
+  return uid;
+}
+function readAccountProfileId(value) {
+  const profileId = lowerText(value);
+  if (!PROFILE_ID_RE.test(profileId))
+    throw new Error("valid account profile id required");
+  return profileId;
+}
+function requireTime(value, label) {
+  const time = Number(value);
+  if (!Number.isSafeInteger(time) || time <= 0)
+    throw new Error(`${label} required`);
+  return time;
+}
+function currentTime(now = Date.now) {
+  return requireTime(typeof now === "function" ? now() : now, "account profile time");
+}
+function readUsername(value, strict = false) {
+  if (value == null || value === "")
+    return null;
+  const username = cleanAvatarUsername(value) || null;
+  if (strict && username !== value)
+    throw new Error("canonical account profile username required");
+  return username;
+}
+function readProfileAvatarVersion(value, strict = false) {
+  if (value == null || value === "")
+    return null;
+  const avatarVersion = readAvatarVersion(value);
+  if (!avatarVersion || strict && avatarVersion !== value) {
+    throw new Error("valid account profile avatar version required");
+  }
+  return avatarVersion;
+}
+function freezeProfile(profile) {
+  return Object.freeze(profile);
+}
+function freezeRegistry(registry) {
+  return Object.freeze({
+    ...registry,
+    profiles: Object.freeze(registry.profiles)
+  });
+}
+function readStoredProfile(value, environment) {
+  requireFields(value, PROFILE_FIELDS, "account profile");
+  if (Object.keys(value).length !== PROFILE_FIELDS.size) {
+    throw new Error("account profile fields incomplete");
+  }
+  const storedEnvironment = requireEnvironment(value.environment);
+  if (storedEnvironment !== value.environment || storedEnvironment !== environment) {
+    throw new Error("account profile environment mismatch");
+  }
+  const uid = requireUid(value.uid);
+  if (uid !== value.uid)
+    throw new Error("canonical account profile uid required");
+  return freezeProfile({
+    profileId: readAccountProfileId(value.profileId),
+    environment,
+    uid,
+    username: readUsername(value.username, true),
+    avatarVersion: readProfileAvatarVersion(value.avatarVersion, true),
+    createdAt: requireTime(value.createdAt, "account profile created time"),
+    lastUsedAt: requireTime(value.lastUsedAt, "account profile last-used time")
+  });
+}
+function profileInput(value, environment) {
+  requireFields(value, INPUT_FIELDS, "account profile input");
+  const inputEnvironment = Object.hasOwn(value, "environment") ? requireEnvironment(value.environment) : environment;
+  if (inputEnvironment !== environment)
+    throw new Error("account profile environment mismatch");
+  return {
+    environment,
+    uid: requireUid(value.uid),
+    username: Object.hasOwn(value, "username") ? readUsername(value.username) : undefined,
+    avatarVersion: Object.hasOwn(value, "avatarVersion") ? readProfileAvatarVersion(value.avatarVersion) : undefined
+  };
+}
+function normalizedRegistry(value) {
+  return readAccountProfiles(value, value?.environment);
+}
+function replaceProfile(registry, profile) {
+  return freezeRegistry({
+    ...registry,
+    profiles: registry.profiles.map((item) => item.profileId === profile.profileId ? profile : item)
+  });
+}
+function makeAccountProfileId() {
+  return toHex(randomBytes(16));
+}
+function emptyAccountProfiles(environment) {
+  return freezeRegistry({
+    version: ACCOUNT_PROFILES_VERSION,
+    environment: requireEnvironment(environment),
+    selectedProfileId: null,
+    profiles: []
+  });
+}
+function readAccountProfiles(value, environment) {
+  const expectedEnvironment = requireEnvironment(environment);
+  if (value == null)
+    return emptyAccountProfiles(expectedEnvironment);
+  requireFields(value, REGISTRY_FIELDS, "account profile registry");
+  if (Object.keys(value).length !== REGISTRY_FIELDS.size) {
+    throw new Error("account profile registry fields incomplete");
+  }
+  if (value.version !== ACCOUNT_PROFILES_VERSION) {
+    throw new Error("unsupported account profile registry version");
+  }
+  const storedEnvironment = requireEnvironment(value.environment);
+  if (storedEnvironment !== value.environment || storedEnvironment !== expectedEnvironment) {
+    throw new Error("account profile registry environment mismatch");
+  }
+  if (!Array.isArray(value.profiles))
+    throw new Error("account profiles required");
+  const profiles = value.profiles.map((profile) => readStoredProfile(profile, expectedEnvironment));
+  const profileIds = new Set;
+  const accountUids = new Set;
+  for (const profile of profiles) {
+    if (profileIds.has(profile.profileId))
+      throw new Error("duplicate account profile id");
+    if (accountUids.has(profile.uid))
+      throw new Error("duplicate account profile uid");
+    profileIds.add(profile.profileId);
+    accountUids.add(profile.uid);
+  }
+  const selectedProfileId = value.selectedProfileId == null ? null : readAccountProfileId(value.selectedProfileId);
+  if (selectedProfileId && !profileIds.has(selectedProfileId)) {
+    throw new Error("selected account profile missing");
+  }
+  return freezeRegistry({
+    version: ACCOUNT_PROFILES_VERSION,
+    environment: expectedEnvironment,
+    selectedProfileId,
+    profiles
+  });
+}
+function accountProfileById(value, profileId) {
+  const registry = normalizedRegistry(value);
+  const id = readAccountProfileId(profileId);
+  return registry.profiles.find((profile) => profile.profileId === id) || null;
+}
+function accountProfilesByRecency(value) {
+  const registry = normalizedRegistry(value);
+  return Object.freeze([...registry.profiles].sort((left, right) => right.lastUsedAt - left.lastUsedAt || left.profileId.localeCompare(right.profileId)));
+}
+function putAccountProfile(value, fields, options = {}) {
+  const registry = normalizedRegistry(value);
+  const input = profileInput(fields, registry.environment);
+  const existing = registry.profiles.find((profile2) => profile2.uid === input.uid) || null;
+  if (existing) {
+    const profile2 = freezeProfile({
+      ...existing,
+      username: input.username === undefined ? existing.username : input.username,
+      avatarVersion: input.avatarVersion === undefined ? existing.avatarVersion : input.avatarVersion
+    });
+    return Object.freeze({ registry: replaceProfile(registry, profile2), profile: profile2, created: false });
+  }
+  const createProfileId = options.createProfileId || makeAccountProfileId;
+  if (typeof createProfileId !== "function")
+    throw new Error("account profile id factory required");
+  const profileId = readAccountProfileId(createProfileId());
+  if (registry.profiles.some((profile2) => profile2.profileId === profileId)) {
+    throw new Error("account profile id collision");
+  }
+  const time = currentTime(options.now);
+  const profile = freezeProfile({
+    profileId,
+    environment: registry.environment,
+    uid: input.uid,
+    username: input.username ?? null,
+    avatarVersion: input.avatarVersion ?? null,
+    createdAt: time,
+    lastUsedAt: time
+  });
+  return Object.freeze({
+    registry: freezeRegistry({ ...registry, profiles: [...registry.profiles, profile] }),
+    profile,
+    created: true
+  });
+}
+function updateAccountProfile(value, profileId, fields) {
+  const registry = normalizedRegistry(value);
+  requireFields(fields, PRESENTATION_FIELDS, "account profile presentation");
+  const existing = accountProfileById(registry, profileId);
+  if (!existing)
+    throw new Error("account profile not found");
+  const profile = freezeProfile({
+    ...existing,
+    username: Object.hasOwn(fields, "username") ? readUsername(fields.username) : existing.username,
+    avatarVersion: Object.hasOwn(fields, "avatarVersion") ? readProfileAvatarVersion(fields.avatarVersion) : existing.avatarVersion
+  });
+  return Object.freeze({ registry: replaceProfile(registry, profile), profile });
+}
+function selectAccountProfile(value, profileId, options = {}) {
+  const registry = normalizedRegistry(value);
+  const existing = accountProfileById(registry, profileId);
+  if (!existing)
+    throw new Error("account profile not found");
+  const selected = freezeProfile({ ...existing, lastUsedAt: currentTime(options.now) });
+  return freezeRegistry({
+    ...registry,
+    selectedProfileId: selected.profileId,
+    profiles: registry.profiles.map((profile) => profile.profileId === selected.profileId ? selected : profile)
+  });
+}
+function removeAccountProfile(value, profileId) {
+  const registry = normalizedRegistry(value);
+  const existing = accountProfileById(registry, profileId);
+  if (!existing)
+    throw new Error("account profile not found");
+  return freezeRegistry({
+    ...registry,
+    selectedProfileId: registry.selectedProfileId === existing.profileId ? null : registry.selectedProfileId,
+    profiles: registry.profiles.filter((profile) => profile.profileId !== existing.profileId)
+  });
+}
+function deselectAccountProfile(value, profileId) {
+  const registry = normalizedRegistry(value);
+  const id = readAccountProfileId(profileId);
+  if (registry.selectedProfileId !== id)
+    return registry;
+  return freezeRegistry({ ...registry, selectedProfileId: null });
+}
+
+// src/accountprofiles.js
+var ACCOUNT_PROFILE_STALE_CODE = "account-profiles/stale";
+var ACCOUNT_PROFILE_AUTH_REQUIRED_CODE = "account-profiles/auth-required";
+var NOOP = () => {};
+var NOOP_RELEASE = () => false;
+function beginAccountProfileTransition(runtime) {
+  if (!runtime)
+    return NOOP_RELEASE;
+  if (typeof runtime.beginTransition !== "function") {
+    throw new Error("account profile transition barrier required");
+  }
+  return runtime.beginTransition();
+}
+function createAccountProfileRuntimeLifecycle(account) {
+  if (!account || typeof account.close !== "function" || typeof account.closeBarrier?.acquire !== "function" || typeof account.closeBarrier?.release !== "function" || typeof account.closeBarrier?.prepare !== "function") {
+    throw new Error("account profile runtime lifecycle ports required");
+  }
+  let closePromise = null;
+  let closeLease = null;
+  let closeStarted = false;
+  return Object.freeze({
+    beginTransition() {
+      if (closeStarted || closeLease) {
+        throw new Error("account profile transition already started");
+      }
+      const lease = account.closeBarrier.acquire();
+      closeLease = lease;
+      let released = false;
+      return () => {
+        if (released || closeStarted)
+          return false;
+        released = true;
+        const didRelease = account.closeBarrier.release(lease);
+        if (didRelease && closeLease === lease)
+          closeLease = null;
+        return didRelease;
+      };
+    },
+    async lock() {
+      if (closePromise)
+        return closePromise;
+      closeStarted = true;
+      await account.closeBarrier.prepare(closeLease);
+    },
+    close() {
+      if (!closePromise) {
+        closeStarted = true;
+        closePromise = Promise.resolve().then(() => account.close());
+      }
+      return closePromise;
+    }
+  });
+}
+function requirePort(value, message) {
+  if (typeof value !== "function")
+    throw new Error(message);
+  return value;
+}
+function staleTransitionError(cause = null) {
+  const error = new Error("account profile transition superseded");
+  error.code = ACCOUNT_PROFILE_STALE_CODE;
+  if (cause)
+    error.cause = cause;
+  return error;
+}
+function authenticationRequiredError() {
+  const error = new Error("account profile authentication required");
+  error.code = ACCOUNT_PROFILE_AUTH_REQUIRED_CODE;
+  return error;
+}
+function isStaleAccountProfileTransition(error) {
+  return error?.code === ACCOUNT_PROFILE_STALE_CODE;
+}
+function requirePorts(options) {
+  const environment = emptyAccountProfiles(options?.environment).environment;
+  const storage = options?.storage;
+  requirePort(storage?.read, "account profile storage read port required");
+  requirePort(storage?.update, "account profile storage update port required");
+  requirePort(storage?.subscribe, "account profile storage subscribe port required");
+  return {
+    environment,
+    storage,
+    resolveAuthenticatedProfile: requirePort(options?.resolveAuthenticatedProfile, "account profile authentication resolver required"),
+    openProfile: requirePort(options?.openProfile, "account profile open port required"),
+    clearNotification: requirePort(options?.clearNotification, "account profile notification-clear port required"),
+    dropPush: requirePort(options?.dropPush, "account profile push-drop port required"),
+    removeProfile: requirePort(options?.removeProfile, "account profile removal port required"),
+    discardProfile: requirePort(options?.discardProfile, "account profile discard port required"),
+    signOutProfile: requirePort(options?.signOutProfile, "account profile sign-out port required"),
+    createProfileId: options.createProfileId,
+    now: options.now,
+    onError: typeof options.onError === "function" ? options.onError : null
+  };
+}
+async function resolveAuthenticatedProfile(owner, generation, reason) {
+  ensureGeneration(owner, generation);
+  const registry = owner.registry;
+  const context = Object.freeze({
+    environment: registry.environment,
+    generation,
+    reason,
+    requestedProfileId: owner.requestedProfileId,
+    isCurrent: () => !owner.closing && !owner.closed && owner.generation === generation
+  });
+  const profileId = await owner.ports.resolveAuthenticatedProfile(registry, context);
+  ensureGeneration(owner, generation);
+  if (profileId == null)
+    return null;
+  const profile = accountProfileById(registry, profileId);
+  if (!profile)
+    throw new Error("authenticated account profile not found");
+  return profile;
+}
+function publicSnapshot(owner) {
+  return Object.freeze({
+    ready: owner.ready,
+    environment: owner.registry.environment,
+    profiles: accountProfilesByRecency(owner.registry),
+    selectedProfileId: owner.registry.selectedProfileId,
+    activeProfileId: owner.active?.profile.profileId || null,
+    status: owner.status,
+    generation: owner.generation,
+    error: owner.error
+  });
+}
+function publish(owner, status = owner.status, error = owner.error) {
+  owner.status = status;
+  owner.error = error;
+  owner.snapshot = publicSnapshot(owner);
+  for (const listener of owner.listeners)
+    listener();
+  return owner.snapshot;
+}
+function enqueue(owner, work) {
+  const operation = owner.tail.then(work, work);
+  owner.tail = operation.catch(NOOP);
+  return operation;
+}
+function ensureAvailable(owner) {
+  if (owner.closing || owner.closed)
+    throw new Error("account profiles closed");
+}
+function ensureReady(owner) {
+  ensureAvailable(owner);
+  if (!owner.ready)
+    throw new Error("account profiles not ready");
+}
+function requestSelection(owner, profileId, invalidateActive = true) {
+  ensureAvailable(owner);
+  owner.generation += 1;
+  owner.requestedProfileId = profileId;
+  if (owner.openingLease)
+    owner.openingLease.valid = false;
+  if (invalidateActive && profileId && owner.active?.profile.profileId !== profileId) {
+    if (owner.active)
+      owner.active.lease.valid = false;
+  }
+  publish(owner);
+  return owner.generation;
+}
+function bindSelection(owner, generation, profileId) {
+  ensureGeneration(owner, generation);
+  owner.requestedProfileId = profileId;
+  if (owner.active?.profile.profileId !== profileId && owner.active) {
+    owner.active.lease.valid = false;
+  }
+  publish(owner);
+}
+function ensureGeneration(owner, generation) {
+  if (owner.closing || owner.closed || owner.generation !== generation) {
+    throw staleTransitionError();
+  }
+}
+function isRequested(owner, generation, profileId) {
+  return !owner.closing && !owner.closed && owner.generation === generation && owner.requestedProfileId === profileId;
+}
+function ensureRequested(owner, generation, profileId) {
+  if (!isRequested(owner, generation, profileId))
+    throw staleTransitionError();
+}
+function transitionContext(owner, lease, reason, details = {}) {
+  return Object.freeze({
+    generation: lease.generation,
+    profileId: lease.profileId,
+    reason,
+    ...details,
+    isCurrent: () => !owner.closing && !owner.closed && lease.valid
+  });
+}
+function report(owner, operation, error, profile = null) {
+  try {
+    owner.ports.onError?.(error, { operation, profile });
+  } catch {}
+}
+async function cleanupBinding(owner, binding, context) {
+  const profile = binding?.profile || null;
+  let failure = null;
+  const attempt = async (operation, work) => {
+    try {
+      await work();
+    } catch (error) {
+      failure ||= error;
+      report(owner, operation, error, profile);
+    }
+  };
+  if (binding) {
+    binding.lease.valid = false;
+    await attempt("lock", () => binding.runtime.lock());
+  }
+  await attempt("clearNotification", () => owner.ports.clearNotification(profile, context));
+  if (binding) {
+    try {
+      await owner.ports.dropPush(profile, binding.runtime, context);
+    } catch (error) {
+      report(owner, "dropPush", error, profile);
+    }
+    await attempt("close", () => binding.runtime.close());
+  }
+  if (failure)
+    throw failure;
+}
+async function deactivate(owner, context) {
+  const binding = owner.active;
+  owner.active = null;
+  if (binding)
+    binding.lease.valid = false;
+  publish(owner);
+  await cleanupBinding(owner, binding, context);
+}
+function requireRuntime(runtime) {
+  if (!runtime || typeof runtime.lock !== "function" || typeof runtime.close !== "function") {
+    throw new Error("opened account profile requires lock and close");
+  }
+  return runtime;
+}
+async function discardCandidate(owner, profile, runtime, lease, reason, cause = null) {
+  if (runtime && typeof runtime.lock === "function" && typeof runtime.close === "function") {
+    const context = transitionContext(owner, lease, reason);
+    try {
+      await cleanupBinding(owner, { profile, runtime, lease }, context);
+    } catch (error) {
+      throw staleTransitionError(error);
+    }
+  } else {
+    try {
+      await runtime?.close?.();
+    } catch (error) {
+      cause ||= error;
+    }
+  }
+  throw staleTransitionError(cause);
+}
+async function finalizeOpen(owner, finalize, context, error = null) {
+  if (typeof finalize !== "function")
+    return error;
+  try {
+    await finalize(context, error);
+    return error;
+  } catch (cleanupError) {
+    report(owner, "discardProfile", cleanupError, null);
+    if (error && !cleanupError.cause)
+      cleanupError.cause = error;
+    return cleanupError;
+  }
+}
+async function openTarget(owner, profile, generation, reason, options = {}) {
+  ensureRequested(owner, generation, profile.profileId);
+  const lease = { generation, profileId: profile.profileId, valid: true };
+  const context = transitionContext(owner, lease, reason, options.details);
+  owner.openingLease = lease;
+  let runtime;
+  try {
+    runtime = await owner.ports.openProfile(profile, context);
+  } catch (error) {
+    if (owner.openingLease === lease)
+      owner.openingLease = null;
+    const failure = await finalizeOpen(owner, options.finalize, context, error);
+    if (!context.isCurrent() || !isRequested(owner, generation, profile.profileId)) {
+      throw staleTransitionError(failure);
+    }
+    throw failure;
+  }
+  try {
+    requireRuntime(runtime);
+  } catch (error) {
+    lease.valid = false;
+    if (owner.openingLease === lease)
+      owner.openingLease = null;
+    const failure = await finalizeOpen(owner, options.finalize, context, error);
+    await runtime?.close?.();
+    throw failure;
+  }
+  const finalizationError = await finalizeOpen(owner, options.finalize, context);
+  if (finalizationError) {
+    if (owner.openingLease === lease)
+      owner.openingLease = null;
+    try {
+      await cleanupBinding(owner, { profile, runtime, lease }, context);
+    } catch (cleanupError) {
+      finalizationError.cause ||= cleanupError;
+    }
+    throw finalizationError;
+  }
+  if (!context.isCurrent() || !isRequested(owner, generation, profile.profileId)) {
+    if (owner.openingLease === lease)
+      owner.openingLease = null;
+    return discardCandidate(owner, profile, runtime, lease, "stale", null);
+  }
+  owner.openingLease = null;
+  owner.active = { profile, runtime, lease };
+  publish(owner, "idle", null);
+  return runtime;
+}
+async function mutateRegistry(owner, update) {
+  owner.storageGeneration += 1;
+  owner.storageUpdating = true;
+  try {
+    const committed = await owner.ports.storage.update(owner.ports.environment, (stored) => {
+      const current = readAccountProfiles(stored, owner.ports.environment);
+      return update(current);
+    });
+    owner.registry = readAccountProfiles(committed, owner.ports.environment);
+    publish(owner);
+    return owner.registry;
+  } finally {
+    owner.storageUpdating = false;
+    owner.storageGeneration += 1;
+  }
+}
+function canonicalSelection(registry, profileId) {
+  if (!profileId || registry.selectedProfileId !== profileId)
+    return null;
+  return accountProfileById(registry, profileId);
+}
+function observationIsCurrent(owner, observation) {
+  return !owner.closing && !owner.closed && !owner.storageUpdating && owner.storageGeneration === observation.storageGeneration && owner.generation === observation.generation;
+}
+function preemptNoncanonicalBindings(owner, registry, observation) {
+  if (!observationIsCurrent(owner, observation))
+    return;
+  const active = owner.active;
+  if (active && !canonicalSelection(registry, active.profile.profileId))
+    active.lease.valid = false;
+  const opening = owner.openingLease;
+  if (!opening || canonicalSelection(registry, opening.profileId))
+    return;
+  opening.valid = false;
+  if (owner.generation === opening.generation && owner.requestedProfileId === opening.profileId) {
+    owner.generation += 1;
+    owner.requestedProfileId = null;
+    publish(owner);
+  }
+}
+function reconcileRequestedProfile(owner, registry, retiredProfileId) {
+  const profileId = owner.requestedProfileId;
+  if (!profileId)
+    return;
+  const pending = owner.reservations.has(profileId) || owner.openingLease?.profileId === profileId;
+  const stillStored = accountProfileById(registry, profileId);
+  if (!pending && (!stillStored || profileId === retiredProfileId && registry.selectedProfileId !== profileId)) {
+    owner.requestedProfileId = null;
+  }
+}
+async function reconcileProfileRegistry(owner, registry, observation) {
+  ensureAvailable(owner);
+  if (!observationIsCurrent(owner, observation))
+    return false;
+  const active = owner.active;
+  const activeProfileId = active?.profile.profileId || null;
+  const currentProfile = canonicalSelection(registry, activeProfileId);
+  owner.registry = registry;
+  reconcileRequestedProfile(owner, registry, currentProfile ? null : activeProfileId);
+  if (currentProfile) {
+    active.profile = currentProfile;
+    publish(owner, "idle", null);
+    return true;
+  }
+  if (!active) {
+    publish(owner, "idle", null);
+    return true;
+  }
+  active.lease.valid = false;
+  publish(owner, "refreshing", null);
+  try {
+    await deactivate(owner, transitionContext(owner, active.lease, "refreshing"));
+  } catch (error) {
+    publish(owner, "error", error);
+    throw error;
+  }
+  if (owner.generation === observation.generation)
+    publish(owner, "idle", null);
+  return true;
+}
+async function refreshProfileRegistry(owner, requestId) {
+  while (owner.refreshRequested === requestId) {
+    ensureAvailable(owner);
+    const observation = {
+      generation: owner.generation,
+      storageGeneration: owner.storageGeneration
+    };
+    const stored = await owner.ports.storage.read(owner.ports.environment);
+    const registry = readAccountProfiles(stored, owner.ports.environment);
+    if (owner.refreshRequested !== requestId)
+      return owner.snapshot;
+    preemptNoncanonicalBindings(owner, registry, observation);
+    const applied = await enqueue(owner, () => owner.refreshRequested === requestId ? reconcileProfileRegistry(owner, registry, observation) : false);
+    if (applied)
+      return owner.snapshot;
+  }
+  return owner.snapshot;
+}
+function requestProfileRefresh(owner) {
+  ensureAvailable(owner);
+  const requestId = owner.refreshRequested + 1;
+  owner.refreshRequested = requestId;
+  const operation = refreshProfileRegistry(owner, requestId).then((snapshot) => owner.refreshRequested === requestId ? snapshot : owner.refreshPromise || owner.snapshot);
+  const tracked = operation.finally(() => {
+    if (owner.refreshPromise === tracked)
+      owner.refreshPromise = null;
+  });
+  owner.refreshPromise = tracked;
+  return tracked;
+}
+async function transitionTo(owner, profile, generation, reason, options = {}) {
+  ensureRequested(owner, generation, profile.profileId);
+  const active = owner.active;
+  if (!options.force && active?.profile.profileId === profile.profileId && active.lease.valid) {
+    const selected2 = await mutateRegistry(owner, (current) => selectAccountProfile(current, profile.profileId, { now: owner.ports.now }));
+    active.profile = accountProfileById(selected2, profile.profileId);
+    publish(owner, "idle", null);
+    return active.runtime;
+  }
+  publish(owner, reason, null);
+  const retiringLease = active?.lease || { generation, profileId: null, valid: false };
+  if (active || options.clearEmpty !== false) {
+    await deactivate(owner, transitionContext(owner, retiringLease, reason));
+  }
+  ensureRequested(owner, generation, profile.profileId);
+  const selected = await mutateRegistry(owner, (current) => selectAccountProfile(current, profile.profileId, { now: owner.ports.now }));
+  ensureRequested(owner, generation, profile.profileId);
+  return openTarget(owner, accountProfileById(selected, profile.profileId), generation, reason, { details: options.openDetails, finalize: options.finalizeOpen });
+}
+async function applyAuthenticatedProfile(owner, profile, generation, reason, options = {}) {
+  ensureGeneration(owner, generation);
+  if (profile) {
+    bindSelection(owner, generation, profile.profileId);
+    await transitionTo(owner, profile, generation, reason, {
+      clearEmpty: options.clearEmpty
+    });
+    return accountProfileById(owner.registry, profile.profileId);
+  }
+  owner.requestedProfileId = null;
+  const lease = owner.active?.lease || { generation, profileId: null, valid: false };
+  if (owner.active)
+    owner.active.lease.valid = false;
+  if (owner.active || options.clearEmpty !== false) {
+    await deactivate(owner, transitionContext(owner, lease, reason));
+  }
+  ensureGeneration(owner, generation);
+  if (owner.registry.selectedProfileId) {
+    const selectedProfileId = owner.registry.selectedProfileId;
+    await mutateRegistry(owner, (current) => deselectAccountProfile(current, selectedProfileId));
+    ensureGeneration(owner, generation);
+  }
+  publish(owner, "idle", null);
+  return null;
+}
+async function resumeAuthenticatedProfile(owner, generation, reason, options = {}) {
+  publish(owner, reason, null);
+  const profile = await resolveAuthenticatedProfile(owner, generation, reason);
+  return applyAuthenticatedProfile(owner, profile, generation, reason, options);
+}
+function transitionFailure(owner, error, generation, profileId) {
+  if (isRequested(owner, generation, profileId))
+    publish(owner, "error", error);
+  return error;
+}
+async function initialize(owner) {
+  try {
+    const stored = await owner.ports.storage.read(owner.ports.environment);
+    owner.registry = readAccountProfiles(stored, owner.ports.environment);
+    const profile = await resolveAuthenticatedProfile(owner, 0, "restoring");
+    owner.ready = true;
+    publish(owner, "restoring", null);
+    if (owner.closing || owner.closed || owner.generation !== 0)
+      return owner.snapshot;
+    await applyAuthenticatedProfile(owner, profile, 0, "restoring");
+    return owner.snapshot;
+  } catch (error) {
+    owner.ready = true;
+    if (isStaleAccountProfileTransition(error))
+      return owner.snapshot;
+    if (!owner.closing && !owner.closed)
+      publish(owner, "error", error);
+    throw error;
+  }
+}
+function requestAuthenticatedProfileResume(owner) {
+  ensureReady(owner);
+  const generation = requestSelection(owner, null, false);
+  return enqueue(owner, async () => {
+    try {
+      return await resumeAuthenticatedProfile(owner, generation, "restoring");
+    } catch (error) {
+      if (!isStaleAccountProfileTransition(error))
+        publish(owner, "error", error);
+      throw error;
+    }
+  });
+}
+function reservedProfileId(owner) {
+  const createProfileId = owner.ports.createProfileId || makeAccountProfileId;
+  if (typeof createProfileId !== "function")
+    throw new Error("account profile id factory required");
+  const profileId = readAccountProfileId(createProfileId());
+  if (accountProfileById(owner.registry, profileId))
+    throw new Error("account profile id collision");
+  return profileId;
+}
+async function discardReservation(owner, reservation, activation, reason) {
+  const lease = {
+    generation: reservation.generation,
+    profileId: reservation.profileId,
+    valid: isRequested(owner, reservation.generation, reservation.profileId)
+  };
+  await owner.ports.discardProfile(reservation.profileId, activation, transitionContext(owner, lease, reason));
+}
+async function activateReservation(owner, reservation, fields, activation) {
+  const { generation, profileId: provisionalProfileId } = reservation;
+  let durable = false;
+  let finalProfileId = null;
+  let discarded = false;
+  const discard = async (reason) => {
+    if (discarded)
+      return;
+    await discardReservation(owner, reservation, activation, reason);
+    discarded = true;
+  };
+  try {
+    ensureGeneration(owner, generation);
+    publish(owner, "switching", null);
+    let authenticatedUid = null;
+    const committed = await mutateRegistry(owner, (current) => {
+      const result = putAccountProfile(current, fields, {
+        createProfileId: () => provisionalProfileId,
+        now: owner.ports.now
+      });
+      authenticatedUid = result.profile.uid;
+      return result.registry;
+    });
+    const profile = committed.profiles.find((item) => item.uid === authenticatedUid) || null;
+    if (!profile)
+      throw new Error("committed account profile missing");
+    finalProfileId = profile.profileId;
+    durable = finalProfileId === provisionalProfileId;
+    ensureGeneration(owner, generation);
+    bindSelection(owner, generation, finalProfileId);
+    const openDetails = { provisionalProfileId };
+    if (activation !== undefined)
+      openDetails.activation = activation;
+    await transitionTo(owner, profile, generation, "switching", {
+      force: true,
+      openDetails,
+      finalizeOpen: finalProfileId === provisionalProfileId ? null : () => discard("deduplicated")
+    });
+    return accountProfileById(owner.registry, finalProfileId);
+  } catch (error) {
+    let failure = error;
+    if (!durable || finalProfileId !== provisionalProfileId) {
+      try {
+        await discard("failed");
+      } catch (cleanupError) {
+        cleanupError.cause ||= error;
+        failure = cleanupError;
+      }
+    }
+    throw transitionFailure(owner, failure, generation, owner.requestedProfileId);
+  }
+}
+function beginAddProfile(owner) {
+  ensureReady(owner);
+  const profileId = reservedProfileId(owner);
+  owner.reservations.add(profileId);
+  const generation = requestSelection(owner, profileId, false);
+  let settled = false;
+  const reservation = Object.freeze({
+    profileId,
+    generation,
+    isCurrent: () => !settled && isRequested(owner, generation, profileId),
+    activate(fields, activation) {
+      if (settled)
+        return Promise.reject(new Error("account profile add reservation settled"));
+      settled = true;
+      return enqueue(owner, () => activateReservation(owner, { generation, profileId }, fields, activation)).finally(() => owner.reservations.delete(profileId));
+    },
+    cancel(activation) {
+      if (settled)
+        return Promise.resolve(false);
+      settled = true;
+      const current = isRequested(owner, generation, profileId);
+      if (current) {
+        owner.generation += 1;
+        owner.requestedProfileId = owner.active?.profile.profileId || null;
+        if (owner.openingLease?.profileId === profileId)
+          owner.openingLease.valid = false;
+        publish(owner);
+      }
+      return enqueue(owner, async () => {
+        await discardReservation(owner, { generation, profileId }, activation, "cancelled");
+        return current;
+      }).finally(() => owner.reservations.delete(profileId));
+    }
+  });
+  return reservation;
+}
+async function switchExisting(owner, profileId, generation) {
+  try {
+    ensureRequested(owner, generation, profileId);
+    const profile = accountProfileById(owner.registry, profileId);
+    if (!profile)
+      throw new Error("account profile not found");
+    const authenticated = await resolveAuthenticatedProfile(owner, generation, "switching");
+    ensureRequested(owner, generation, profileId);
+    if (authenticated?.profileId !== profileId) {
+      owner.requestedProfileId = owner.active?.profile.profileId || null;
+      const error = authenticationRequiredError();
+      publish(owner, "error", error);
+      throw error;
+    }
+    if (owner.active && owner.active.profile.profileId !== profileId)
+      owner.active.lease.valid = false;
+    await transitionTo(owner, profile, generation, "switching");
+    return accountProfileById(owner.registry, profileId);
+  } catch (error) {
+    throw transitionFailure(owner, error, generation, profileId);
+  }
+}
+async function updateStoredProfile(owner, profileId, fields) {
+  ensureAvailable(owner);
+  const registry = await mutateRegistry(owner, (current) => updateAccountProfile(current, profileId, fields).registry);
+  const profile = accountProfileById(registry, profileId);
+  if (owner.active?.profile.profileId === profileId)
+    owner.active.profile = profile;
+  publish(owner, owner.status, null);
+  return profile;
+}
+async function signOutStoredProfile(owner, profile) {
+  try {
+    publish(owner, "signing-out", null);
+    if (!owner.active || owner.active.profile.profileId === profile.profileId) {
+      const lease = owner.active?.lease || {
+        generation: owner.generation,
+        profileId: profile.profileId,
+        valid: false
+      };
+      await deactivate(owner, transitionContext(owner, lease, "signing-out"));
+    }
+    const signOutLease = {
+      generation: owner.generation,
+      profileId: profile.profileId,
+      valid: true
+    };
+    let signOutFailure = null;
+    try {
+      await owner.ports.signOutProfile(profile, transitionContext(owner, signOutLease, "signing-out"));
+    } catch (error) {
+      signOutFailure = error;
+      report(owner, "signOutProfile", error, profile);
+    }
+    await mutateRegistry(owner, (current) => current.selectedProfileId === profile.profileId ? deselectAccountProfile(current, profile.profileId) : current);
+    if (owner.requestedProfileId === profile.profileId)
+      owner.requestedProfileId = null;
+    await resumeAuthenticatedProfile(owner, owner.generation, "restoring", { clearEmpty: false });
+    if (signOutFailure)
+      throw signOutFailure;
+    return profile;
+  } catch (error) {
+    publish(owner, "error", error);
+    throw error;
+  }
+}
+function requestProfileSignOut(owner) {
+  ensureReady(owner);
+  const profileId = owner.active?.profile.profileId || owner.registry.selectedProfileId;
+  const profile = profileId ? accountProfileById(owner.registry, profileId) : null;
+  if (!profile)
+    return Promise.reject(new Error("active account profile required"));
+  owner.generation += 1;
+  owner.requestedProfileId = null;
+  if (owner.openingLease)
+    owner.openingLease.valid = false;
+  if (owner.active)
+    owner.active.lease.valid = false;
+  publish(owner);
+  return enqueue(owner, () => signOutStoredProfile(owner, profile));
+}
+async function removeStoredProfile(owner, profileId) {
+  ensureAvailable(owner);
+  const profile = accountProfileById(owner.registry, profileId);
+  if (!profile)
+    throw new Error("account profile not found");
+  const wasActive = owner.active?.profile.profileId === profileId;
+  try {
+    publish(owner, "removing", null);
+    if (wasActive) {
+      owner.active.lease.valid = false;
+      const lease = owner.active.lease;
+      await deactivate(owner, transitionContext(owner, lease, "removing"));
+    }
+    const removalLease = { generation: owner.generation, profileId, valid: true };
+    await owner.ports.removeProfile(profile, transitionContext(owner, removalLease, "removing"));
+    const registry = await mutateRegistry(owner, (current) => accountProfileById(current, profileId) ? removeAccountProfile(current, profileId) : current);
+    if (owner.requestedProfileId === profileId) {
+      owner.requestedProfileId = owner.active?.profile.profileId || registry.selectedProfileId;
+    }
+    if (wasActive) {
+      await resumeAuthenticatedProfile(owner, owner.generation, "restoring", { clearEmpty: false });
+    } else
+      publish(owner, "idle", null);
+    return profile;
+  } catch (error) {
+    let failure = error;
+    if (wasActive && !owner.active) {
+      try {
+        await resumeAuthenticatedProfile(owner, owner.generation, "restoring", { clearEmpty: false });
+      } catch (recoveryError) {
+        recoveryError.cause ||= error;
+        failure = recoveryError;
+      }
+    }
+    publish(owner, "error", failure);
+    throw failure;
+  }
+}
+function requestProfileRemoval(owner, profileId) {
+  ensureAvailable(owner);
+  if (owner.ready && !accountProfileById(owner.registry, profileId)) {
+    return Promise.reject(new Error("account profile not found"));
+  }
+  if (owner.openingLease?.profileId === profileId || owner.requestedProfileId === profileId) {
+    owner.generation += 1;
+    owner.requestedProfileId = owner.active?.profile.profileId || null;
+    if (owner.openingLease?.profileId === profileId)
+      owner.openingLease.valid = false;
+    publish(owner);
+  }
+  if (owner.active?.profile.profileId === profileId)
+    owner.active.lease.valid = false;
+  return enqueue(owner, () => removeStoredProfile(owner, profileId));
+}
+function closeProfiles(owner) {
+  if (owner.closePromise)
+    return owner.closePromise;
+  owner.closing = true;
+  owner.stopStorage();
+  owner.stopStorage = NOOP;
+  owner.generation += 1;
+  owner.requestedProfileId = null;
+  if (owner.openingLease)
+    owner.openingLease.valid = false;
+  if (owner.active)
+    owner.active.lease.valid = false;
+  owner.closePromise = enqueue(owner, async () => {
+    let failure = null;
+    try {
+      const lease = owner.active?.lease || { generation: owner.generation, profileId: null, valid: false };
+      await deactivate(owner, transitionContext(owner, lease, "closed"));
+    } catch (error) {
+      failure = error;
+    }
+    owner.closed = true;
+    owner.closing = false;
+    publish(owner, "closed", failure);
+    owner.listeners.clear();
+    if (failure)
+      throw failure;
+  });
+  return owner.closePromise;
+}
+function createAccountProfiles(options = {}) {
+  const ports = requirePorts(options);
+  const owner = {
+    ports,
+    registry: emptyAccountProfiles(ports.environment),
+    active: null,
+    openingLease: null,
+    requestedProfileId: null,
+    generation: 0,
+    ready: false,
+    closing: false,
+    closed: false,
+    closePromise: null,
+    status: "loading",
+    error: null,
+    snapshot: null,
+    listeners: new Set,
+    reservations: new Set,
+    storageGeneration: 0,
+    storageUpdating: false,
+    refreshRequested: 0,
+    refreshPromise: null,
+    stopStorage: NOOP,
+    tail: Promise.resolve()
+  };
+  owner.snapshot = publicSnapshot(owner);
+  const ready = enqueue(owner, () => initialize(owner));
+  owner.stopStorage = ports.storage.subscribe(ports.environment, () => {
+    if (owner.closing || owner.closed)
+      return;
+    requestProfileRefresh(owner).catch((error) => report(owner, "refresh", error));
+  });
+  if (typeof owner.stopStorage !== "function") {
+    throw new Error("account profile storage subscribe must return unsubscribe");
+  }
+  return Object.freeze({
+    ready,
+    getSnapshot: () => owner.snapshot,
+    subscribe(listener) {
+      if (typeof listener !== "function")
+        return NOOP;
+      owner.listeners.add(listener);
+      return () => owner.listeners.delete(listener);
+    },
+    beginAdd: () => beginAddProfile(owner),
+    update(profileId, fields) {
+      return enqueue(owner, () => updateStoredProfile(owner, profileId, fields));
+    },
+    switchTo(profileId) {
+      if (owner.ready && !accountProfileById(owner.registry, profileId)) {
+        return Promise.reject(new Error("account profile not found"));
+      }
+      const generation = requestSelection(owner, profileId, false);
+      return enqueue(owner, () => switchExisting(owner, profileId, generation));
+    },
+    resumeAuthenticated: () => requestAuthenticatedProfileResume(owner),
+    refresh: () => requestProfileRefresh(owner),
+    signOut: () => requestProfileSignOut(owner),
+    remove: (profileId) => requestProfileRemoval(owner, profileId),
+    getActiveRuntime: () => owner.active?.runtime || null,
+    close: () => closeProfiles(owner)
+  });
+}
+export {
+  ACCOUNT_PROFILE_AUTH_REQUIRED_CODE,
+  ACCOUNT_PROFILE_STALE_CODE,
+  beginAccountProfileTransition,
+  createAccountProfileRuntimeLifecycle,
+  createAccountProfiles,
+  isStaleAccountProfileTransition
+};