@glyphteck/veyl 0.67.0 → 0.69.0

package/dist/accountprofiles.js

@@ -44,6 +44,14 @@ var USERNAME_MAX_CHARS = 12;
 var PASSWORD_MIN_CHARS = 15;
 var PASSWORD_MAX_CHARS = 64;
 var PASSWORD_MAX_BYTES = 4 * 1024;
+var ACCOUNT_CONNECTION_SLOW_MS = 4 * MS_PER_SECOND;
+var ACCOUNT_CONNECTION_UNAVAILABLE_MS = 15 * MS_PER_SECOND;
+var ACCOUNT_CONNECTION_RETRY_MIN_MS = MS_PER_SECOND;
+var ACCOUNT_CONNECTION_RETRY_MAX_MS = 30 * MS_PER_SECOND;
+var AUTOLOCK_MIN_MINUTES = 1;
+var AUTOLOCK_MAX_MINUTES = 60;
+var CHAT_MESSAGE_EDIT_WINDOW_MS = 10 * MINUTE_MS;
+var CHAT_SEND_CONNECTION_WAIT_MS = 30 * MS_PER_SECOND;
 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;
@@ -115,6 +123,7 @@ 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_LARGE_GROUP_MENTION_MAX_TARGETS = 16;
 var CHAT_MAX_TEXT_CHARS = 2048;
 var CHAT_TITLE_INPUT_MAX_CHARS = 16;
 var CHAT_MAX_REACTIONS = CHAT_MAX_MEMBERS;
@@ -283,7 +292,7 @@ function normalizePasskeyLoginError(error, options = {}) {
     return passkeyError(PASSKEY_UNLINKED, "This passkey is no longer linked to an account.", error);
   }
   if (error?.code === "functions/failed-precondition") {
-    return passkeyError(PASSKEY_RP_MISMATCH, "This passkey belongs to a different Glyphteck passkey setup.", error);
+    return passkeyError(PASSKEY_RP_MISMATCH, "This passkey belongs to a different Veyl passkey setup.", error);
   }
   return error;
 }
@@ -292,7 +301,7 @@ function normalizePasskeyRegisterError(error, options = {}) {
     return passkeyError(PASSKEY_PROVIDER_ALREADY_LINKED, "you already have a passkey for this account", error);
   }
   if (error?.code === "functions/failed-precondition") {
-    return passkeyError(PASSKEY_RP_MISMATCH, "This passkey belongs to a different Glyphteck passkey setup.", error);
+    return passkeyError(PASSKEY_RP_MISMATCH, "This passkey belongs to a different Veyl passkey setup.", error);
   }
   if (options.invalidArgument === true && error?.code === "functions/invalid-argument" && error?.message) {
     return passkeyError(PASSKEY_REGISTER_INVALID, error.message, error);
@@ -563,6 +572,71 @@ function deselectAccountProfile(value, profileId) {
   return freezeRegistry({ ...registry, selectedProfileId: null });
 }
 
+// ../../core/account/scope.js
+var ACCOUNT_SCOPE_STALE_CODE = "account-scope/stale";
+var PROFILE_ID_RE2 = /^[0-9a-f]{32}$/;
+var ACCOUNT_SCOPE_CAPABILITIES = new WeakSet;
+function requireGeneration(value) {
+  const generation = Number(value);
+  if (!Number.isSafeInteger(generation) || generation < 0) {
+    throw new Error("account scope generation required");
+  }
+  return generation;
+}
+function requireProfileId(value) {
+  const profileId = lowerText(value);
+  if (!PROFILE_ID_RE2.test(profileId))
+    throw new Error("account scope profile id required");
+  return profileId;
+}
+function requireText(value, label) {
+  const text = cleanText(value);
+  if (!text)
+    throw new Error(`${label} required`);
+  return text;
+}
+function staleAccountScopeError(scope = null) {
+  const error = new Error("account scope is no longer active");
+  error.code = ACCOUNT_SCOPE_STALE_CODE;
+  error.profileId = scope?.profileId || null;
+  error.generation = Number.isSafeInteger(scope?.generation) ? scope.generation : null;
+  return error;
+}
+function createAccountScope({
+  environment,
+  generation,
+  isCurrent,
+  profileId,
+  uid
+} = {}) {
+  if (typeof isCurrent !== "function")
+    throw new Error("account scope current-state port required");
+  const normalizedEnvironment = lowerText(requireText(environment, "account scope environment"));
+  const normalizedGeneration = requireGeneration(generation);
+  const normalizedProfileId = requireProfileId(profileId);
+  const normalizedUid = requireText(uid, "account scope uid");
+  const accountOwnerKey = `${normalizedEnvironment}:${normalizedProfileId}:${normalizedUid}`;
+  const scope = {
+    accountOwnerKey,
+    environment: normalizedEnvironment,
+    generation: normalizedGeneration,
+    key: `${accountOwnerKey}:${normalizedGeneration}`,
+    profileId: normalizedProfileId,
+    uid: normalizedUid,
+    isCurrent: () => isCurrent() === true,
+    assertCurrent() {
+      if (!scope.isCurrent())
+        throw staleAccountScopeError(scope);
+      return scope;
+    }
+  };
+  ACCOUNT_SCOPE_CAPABILITIES.add(scope);
+  return Object.freeze(scope);
+}
+function isAccountScope(value) {
+  return !!value && typeof value === "object" && ACCOUNT_SCOPE_CAPABILITIES.has(value);
+}
+
 // src/accountprofiles.js
 var ACCOUNT_PROFILE_STALE_CODE = "account-profiles/stale";
 var ACCOUNT_PROFILE_AUTH_REQUIRED_CODE = "account-profiles/auth-required";
@@ -678,12 +752,16 @@ async function resolveAuthenticatedProfile(owner, generation, reason, details =
   return profile;
 }
 function publicSnapshot(owner) {
+  const activeBinding = owner.active?.lease.valid === true && owner.active.scope?.isCurrent() === true ? owner.active.binding : null;
   return Object.freeze({
     ready: owner.ready,
     environment: owner.registry.environment,
     profiles: accountProfilesByRecency(owner.registry),
     selectedProfileId: owner.registry.selectedProfileId,
-    activeProfileId: owner.active?.profile.profileId || null,
+    activeBinding,
+    activeProfileId: activeBinding ? owner.active.profile.profileId : null,
+    activeScope: activeBinding?.scope || null,
+    activeScopeKey: activeBinding?.scope.key || null,
     status: owner.status,
     generation: owner.generation,
     error: owner.error
@@ -745,12 +823,23 @@ function ensureRequested(owner, generation, profileId) {
     throw staleTransitionError();
 }
 function transitionContext(owner, lease, reason, details = {}) {
+  const profile = lease.profileId ? owner.registry.profiles.find((item) => item.profileId === lease.profileId) || null : null;
+  const isCurrent = () => !owner.closing && !owner.closed && lease.valid;
   return Object.freeze({
+    environment: owner.registry.environment,
     generation: lease.generation,
     profileId: lease.profileId,
+    uid: profile?.uid || null,
     reason,
     ...details,
-    isCurrent: () => !owner.closing && !owner.closed && lease.valid
+    scope: profile ? createAccountScope({
+      environment: owner.registry.environment,
+      generation: lease.generation,
+      profileId: lease.profileId,
+      uid: profile.uid,
+      isCurrent
+    }) : null,
+    isCurrent
   });
 }
 function report(owner, operation, error, profile = null) {
@@ -773,7 +862,13 @@ async function cleanupBinding(owner, binding, context) {
     binding.lease.valid = false;
     await attempt("lock", () => binding.runtime.lock());
   }
-  await attempt("clearNotification", () => owner.ports.clearNotification(profile, context));
+  if (binding?.scope?.key && binding.scope.accountOwnerKey) {
+    await attempt("clearNotification", () => owner.ports.clearNotification(Object.freeze({
+      owner: binding.scope,
+      profile,
+      context
+    })));
+  }
   if (binding) {
     try {
       await owner.ports.dropPush(profile, binding.runtime, context);
@@ -873,7 +968,13 @@ async function openTarget(owner, profile, generation, reason, options = {}) {
     return discardCandidate(owner, profile, runtime, lease, "stale", null);
   }
   owner.openingLease = null;
-  owner.active = { profile, runtime, lease };
+  owner.active = {
+    profile,
+    runtime,
+    lease,
+    scope: context.scope,
+    binding: Object.freeze({ runtime, scope: context.scope })
+  };
   publish(owner, "idle", null);
   return runtime;
 }
@@ -1185,6 +1286,7 @@ function beginAddProfile(owner) {
   return reservation;
 }
 async function switchExisting(owner, profileId, generation) {
+  const sourceProfileId = owner.active?.profile.profileId || null;
   try {
     ensureRequested(owner, generation, profileId);
     const profile = accountProfileById(owner.registry, profileId);
@@ -1203,7 +1305,21 @@ async function switchExisting(owner, profileId, generation) {
     await transitionTo(owner, profile, generation, "switching");
     return accountProfileById(owner.registry, profileId);
   } catch (error) {
-    throw transitionFailure(owner, error, generation, profileId);
+    let failure = error;
+    if (sourceProfileId && sourceProfileId !== profileId && isRequested(owner, generation, profileId)) {
+      const sourceProfile = accountProfileById(owner.registry, sourceProfileId);
+      if (sourceProfile) {
+        try {
+          bindSelection(owner, generation, sourceProfileId);
+          await transitionTo(owner, sourceProfile, generation, "restoring", { force: true });
+        } catch (recoveryError) {
+          recoveryError.cause ||= error;
+          failure = recoveryError;
+          publish(owner, "error", recoveryError);
+        }
+      }
+    }
+    throw transitionFailure(owner, failure, generation, profileId);
   }
 }
 async function updateStoredProfile(owner, profileId, fields) {
@@ -1414,7 +1530,7 @@ function createAccountProfiles(options = {}) {
     refresh: () => requestProfileRefresh(owner),
     signOut: (profileId) => requestProfileSignOut(owner, profileId),
     remove: (profileId) => requestProfileRemoval(owner, profileId),
-    getActiveRuntime: () => owner.active?.runtime || null,
+    getActiveBinding: () => owner.snapshot.activeBinding,
     close: () => closeProfiles(owner)
   });
 }

package/dist/auth.js

@@ -77,7 +77,7 @@ function normalizePasskeyLoginError(error, options = {}) {
     return passkeyError(PASSKEY_UNLINKED, "This passkey is no longer linked to an account.", error);
   }
   if (error?.code === "functions/failed-precondition") {
-    return passkeyError(PASSKEY_RP_MISMATCH, "This passkey belongs to a different Glyphteck passkey setup.", error);
+    return passkeyError(PASSKEY_RP_MISMATCH, "This passkey belongs to a different Veyl passkey setup.", error);
   }
   return error;
 }
@@ -86,7 +86,7 @@ function normalizePasskeyRegisterError(error, options = {}) {
     return passkeyError(PASSKEY_PROVIDER_ALREADY_LINKED, "you already have a passkey for this account", error);
   }
   if (error?.code === "functions/failed-precondition") {
-    return passkeyError(PASSKEY_RP_MISMATCH, "This passkey belongs to a different Glyphteck passkey setup.", error);
+    return passkeyError(PASSKEY_RP_MISMATCH, "This passkey belongs to a different Veyl passkey setup.", error);
   }
   if (options.invalidArgument === true && error?.code === "functions/invalid-argument" && error?.message) {
     return passkeyError(PASSKEY_REGISTER_INVALID, error.message, error);
@@ -95,7 +95,7 @@ function normalizePasskeyRegisterError(error, options = {}) {
 }
 
 // ../../core/agreement.js
-var TERMS_VERSION = "2026-08-22.4";
+var TERMS_VERSION = "2026-09-01.1";
 var CURRENT_AGREEMENT = Object.freeze({
   termsVersion: TERMS_VERSION
 });