pyric 0.1.0-alpha.21 → 0.1.0-alpha.24

package/src/ai/scripting.ts

@@ -19,6 +19,7 @@
 
 import {
   ScriptedEngine,
+  type AiEngineStatus,
   type ScriptEntry,
   type ScriptMatcher,
   type ScriptRespond,
@@ -28,7 +29,14 @@ import { AIError, AIErrorCode } from './errors.js';
 import { targetOf } from './target.js';
 import type { AI } from './types.js';
 
-export type { ScriptEntry, ScriptMatcher, ScriptRespond } from './broker/index.js';
+export { lastUserText } from './broker/index.js';
+export type { AiEngineStatus, GenerateContentRequest, ScriptEntry, ScriptMatcher, ScriptRespond } from './broker/index.js';
+
+/** One queued entry, beside whether it has already answered a call. */
+export interface ScriptedEntryStatus {
+  entry: ScriptEntry;
+  consumed: boolean;
+}
 
 /** An HTTP error capture pasted whole: status + the wire error body. */
 export interface HttpErrorRespond {
@@ -87,21 +95,48 @@ function normalizeEntry(entry: ScriptingEntry): ScriptEntry {
  * entries are unconditional FIFO (broker semantics).
  */
 export function script(ai: AI, entries: ScriptingEntry[]): void {
+  scriptedEngineOf(ai, 'script(ai, entries)').push(...entries.map(normalizeEntry));
+}
+
+/** The scripted engine behind a sandbox AI handle, or a refusal matching {@link script}'s own. */
+function scriptedEngineOf(ai: AI, caller: string): ScriptedEngine {
   const target = targetOf(ai);
   if (target.kind !== 'sandbox') {
-    throw new AIError(
-      AIErrorCode.UNSUPPORTED,
-      'script(ai, entries) is unavailable for a transport-backed AI handle.',
-    );
+    throw new AIError(AIErrorCode.UNSUPPORTED, `${caller} is unavailable for a transport-backed AI handle.`);
   }
   const engine = target.broker.engine;
   if (!(engine instanceof ScriptedEngine)) {
     throw new AIError(
       AIErrorCode.UNSUPPORTED,
-      "script(ai, entries) requires the scripted engine (the getAI(sandbox) default, or engine: { kind: 'scripted' }).",
+      `${caller} requires the scripted engine (the getAI(sandbox) default, or engine: { kind: 'scripted' }).`,
     );
   }
-  engine.push(...entries.map(normalizeEntry));
+  return engine;
+}
+
+/** Empty the scripted engine's entry queue. A later call matches nothing until entries are pushed again. */
+export function clearScripts(ai: AI): void {
+  scriptedEngineOf(ai, 'clearScripts(ai)').clear();
+}
+
+/** The scripted engine's queued entries, each beside whether it has already answered a call. */
+export function scripts(ai: AI): ReadonlyArray<ScriptedEntryStatus> {
+  return scriptedEngineOf(ai, 'scripts(ai)').list();
+}
+
+/**
+ * The resolved answer engine's mode, model, upstream, and whether a key is
+ * configured. Never the key itself. Works for whichever engine is
+ * configured, not only the scripted one, so a sandbox running the gemini
+ * production-passthrough engine still reports through this call; `script`,
+ * `clearScripts`, and `scripts` are what stay scoped to the scripted engine.
+ */
+export function aiStatus(ai: AI): AiEngineStatus {
+  const target = targetOf(ai);
+  if (target.kind !== 'sandbox') {
+    throw new AIError(AIErrorCode.UNSUPPORTED, 'aiStatus(ai) is unavailable for a transport-backed AI handle.');
+  }
+  return target.broker.describeStatus();
 }
 
 /**

package/src/app/internal.ts

@@ -10,6 +10,7 @@ import {
 export { bindAppRegistrySandbox } from './registry.js';
 export { firebaseOptionsEqual } from './options.js';
 export { isSandboxAppDeleted };
+export { deferredEntry, PyricDeferredApiError, type DeferredApi } from '../deferred/entry.js';
 
 /** Host-only lifecycle seam for resources owned by one FirebaseApp. */
 export function registerAppCleanup(

package/src/auth/email-link.ts

@@ -52,7 +52,7 @@ import {
   type ActionCodeSettings,
 } from './action-codes.js';
 import { targetOf } from './target.js';
-import type { Auth, UserCredential } from './types.js';
+import type { Auth, User, UserCredential } from './types.js';
 
 /**
  * `sendSignInLinkToEmail(auth, email, settings)` — mirror of
@@ -108,8 +108,14 @@ export async function sendSignInLinkToEmail(
  */
 export function isSignInWithEmailLink(auth: Auth, link: string): boolean {
   targetOf(auth);
+  return isEmailSignInLink(link);
+}
+
+/** Shared link predicate for page handles that do not own an Auth backend. */
+export function isEmailSignInLink(link: string): boolean {
   const parsed = ActionCodeURL.parseLink(link);
-  return parsed !== null && parsed.operation === ActionCodeOperation.EMAIL_SIGNIN;
+  const isSignIn = parsed !== null && parsed.operation === ActionCodeOperation.EMAIL_SIGNIN;
+  return isSignIn;
 }
 
 /**
@@ -133,11 +139,25 @@ export async function signInWithEmailLink(
   email: string,
   link: string,
 ): Promise<UserCredential> {
+  const { user, isNewUser } = resolveEmailLinkIdentity(auth, email, link);
+  await targetOf(auth).backend.transitionCurrentUser(user, 'password');
+  return {
+    user,
+    // Email/password credentials have a null providerId, including email links.
+    providerId: null,
+    operationType: 'signIn',
+    _additionalUserInfo: { isNewUser, profile: {}, providerId: null },
+  };
+}
+
+/** Redeem and resolve the account without changing the backend's global session. */
+export function resolveEmailLinkIdentity(auth: Auth, email: string, link: string): { user: User; isNewUser: boolean } {
   const t = targetOf(auth);
   const target = t;
   target.backend.assertProviderEnabled('password');
   const parsed = ActionCodeURL.parseLink(link);
-  if (!parsed) {
+  const missingLink = parsed === null;
+  if (missingLink) {
     // Oracle: a `mode=signIn` link with no oobCode throws
     // `auth/argument-error` client-side, NOT invalid-action-code — the
     // SDK never gets far enough to ask the server about a code it cannot
@@ -147,7 +167,8 @@ export async function signInWithEmailLink(
       'signInWithEmailLink: the link is not a valid email sign-in link (no oobCode).',
     );
   }
-  if (parsed.operation !== ActionCodeOperation.EMAIL_SIGNIN) {
+  const wrongOperation = parsed.operation !== ActionCodeOperation.EMAIL_SIGNIN;
+  if (wrongOperation) {
     throw makeAuthError(
       'auth/argument-error',
       `signInWithEmailLink: the link authorizes ${parsed.operation}, not an email sign-in.`,
@@ -156,20 +177,23 @@ export async function signInWithEmailLink(
   assertEmail(email, 'signInWithEmailLink');
 
   const spec = target.backend.peekActionCode(parsed.code);
-  if (!spec) {
+  const missingCode = spec === undefined;
+  if (missingCode) {
     throw makeAuthError(
       'auth/invalid-action-code',
       'signInWithEmailLink: the action code is invalid. This can happen if the code is malformed, expired, or has already been used.',
     );
   }
-  if (spec.expired) {
+  const expired = spec.expired === true;
+  if (expired) {
     throw makeAuthError('auth/expired-action-code', 'signInWithEmailLink: the action code has expired.');
   }
   // The address the caller passed must be the one the link was issued
   // for. This is the check that makes the flow safe against a link
   // pasted into the wrong session — upstream requires the caller to
   // supply the email precisely so it can be compared.
-  if (spec.email.toLowerCase() !== email.toLowerCase()) {
+  const wrongEmail = spec.email.toLowerCase() !== email.toLowerCase();
+  if (wrongEmail) {
     throw makeAuthError(
       'auth/invalid-email',
       'signInWithEmailLink: the email provided does not match the address this sign-in link was issued for.',
@@ -180,20 +204,7 @@ export async function signInWithEmailLink(
   const { stored, isNewUser } = target.backend.upsertEmailLinkUser(spec.email);
   target.backend.assertSignInAllowed(stored.uid);
   const user = target.backend.buildUserFromStored(stored);
-  await target.backend.transitionCurrentUser(user, 'password');
-  return {
-    user,
-    // Email/password sign-ins carry `providerId: null` on the credential
-    // — the same oracle-pinned rule `signInWithEmailAndPassword` follows
-    // (observations/auth/auth-createUser-operationType.json).
-    providerId: null,
-    operationType: 'signIn',
-    _additionalUserInfo: {
-      isNewUser,
-      profile: {},
-      providerId: null,
-    },
-  };
+  return { user, isNewUser };
 }
 
 /** The email-link sign-in method id, for symmetry with

package/src/auth/events.ts

@@ -0,0 +1,29 @@
+/**
+ * What the auth surface puts on the sandbox event stream.
+ *
+ * The sandbox core reads this record to derive the `auth` arm of
+ * `ServiceMutationEvent`; the emit sites in `auth/sandbox-backend.ts` are
+ * typed against the operations declared here.
+ */
+import type { ServiceEventRecord } from '../sandbox/types/service-event-record.js';
+
+export const AUTH_EVENT_RECORD = {
+  service: 'auth',
+  operations: [
+    'user_create',
+    'user_update',
+    'user_delete',
+    'users_clear',
+    'sign_in',
+    'sign_out',
+    'provider_config_update',
+  ],
+  target: {
+    name: 'uid',
+    description: "The mutated user's uid, or '*' when every user was cleared.",
+    always: false,
+  },
+} as const satisfies ServiceEventRecord;
+
+/** Every operation the auth surface emits. */
+export type AuthEventOperation = (typeof AUTH_EVENT_RECORD)['operations'][number];

package/src/auth/factor-id.ts

@@ -0,0 +1,7 @@
+/** Runtime values from the installed Firebase SDK. */
+
+export const FactorId = {
+  PHONE: "phone",
+  TOTP: "totp",
+} as const;
+export type FactorId = (typeof FactorId)[keyof typeof FactorId];

package/src/auth/index.ts

@@ -1,2 +1,4 @@
 /** Public `pyric/auth` barrel mirroring `firebase/auth`. */
 export * from './modular.js';
+
+export { FactorId } from './factor-id.js';

package/src/auth/instances.ts

@@ -108,12 +108,24 @@ function makeAuthHandle(target: Target, app?: FirebaseApp): Auth {
       return signOut(handle as Auth);
     },
   } as Auth;
-  return Object.defineProperty(handle, 'currentUser', {
+  Object.defineProperty(handle, 'currentUser', {
     enumerable: true,
     get(): User | null {
       return target.backend.getCurrentUser();
     },
   });
+  // `tenantId` is an accessor rather than a plain field so the value an app
+  // assigns is the value the backend reads when it fixes a sign-in's tenant.
+  // Every handle over one backend therefore agrees on the active tenant.
+  return Object.defineProperty(handle, 'tenantId', {
+    enumerable: true,
+    get(): string | null {
+      return target.backend.getTenantId();
+    },
+    set(tenantId: string | null): void {
+      target.backend.setTenantId(tenantId);
+    },
+  });
 }
 
 export function connectAuthEmulator(

package/src/auth/internal.ts

@@ -0,0 +1,24 @@
+/**
+ * `pyric/auth/internal` — host-only seam for the sandbox auth backend, on the
+ * `pyric/sandbox/internal` / `pyric/storage/internal` precedent.
+ *
+ * The default-avatar generator is the sandbox's built-in image of last resort.
+ * The dev server's `/__pyric/assets/avatar/<uid>` route mounts it as the asset
+ * resolver's fallback, so a served page and an in-page sandbox with no server
+ * render the SAME deterministic face for a uid. `@pyric/cli` reads it through
+ * this subpath rather than reaching into the package's source tree.
+ *
+ * **Not part of the public API.** These exports mirror no Firebase surface and
+ * are never reached by application code, so the conformance census does not
+ * measure them. Shape subject to change without breaking-change semantics
+ * across versions.
+ */
+export {
+  avatarSeed,
+  defaultAvatarDataUri,
+  defaultAvatarMint,
+  defaultAvatarSvg,
+} from './sandbox/default-avatar.js';
+export type { AvatarMint, AvatarMintInput } from './sandbox/default-avatar.js';
+export { isEmailSignInLink, resolveEmailLinkIdentity } from './email-link.js';
+export { resolveCustomTokenIdentity } from './tokens.js';

package/src/auth/modular.ts

@@ -26,6 +26,7 @@ export type {
   UpdateUserRequest,
 } from './sandbox-backend.js';
 export type { AuthMailResolver, OutboundAuthMail } from './sandbox-auth-flow.js';
+export type { AvatarMint, AvatarMintInput } from './sandbox/default-avatar.js';
 
 export {
   EmailAuthProvider,
@@ -116,3 +117,29 @@ export {
   useDeviceLanguage,
 } from './user-lifecycle.js';
 export { sandbox } from './sandbox/driver.js';
+import type { AuthLens } from '../sandbox/types/operation.js';
+export type { AuthLens };
+
+let _activeAuthLens: AuthLens | undefined;
+const _authLensListeners = new Set<(lens: AuthLens | undefined) => void>();
+
+/** Switch the active AuthLens for subsequent data operations. */
+export function switchAuthLens(lens: AuthLens | undefined): void {
+  _activeAuthLens = lens && lens.mode === 'app-session' ? undefined : lens;
+  for (const cb of [..._authLensListeners]) {
+    cb(_activeAuthLens);
+  }
+}
+
+/** Return the currently active AuthLens, or undefined if using the default app session. */
+export function getAuthLens(): AuthLens | undefined {
+  return _activeAuthLens;
+}
+
+/** Subscribe to AuthLens changes. Returns an unsubscribe function. */
+export function onAuthLensChanged(cb: (lens: AuthLens | undefined) => void): () => void {
+  _authLensListeners.add(cb);
+  return () => {
+    _authLensListeners.delete(cb);
+  };
+}

package/src/auth/reauth.ts

@@ -179,8 +179,9 @@ function completeReauth(
   // Force a refresh: a successful re-auth produces a NEW token with a new
   // authTime. That advance is the observable trace of the re-verification
   // (and what prod's recent-login gate reads).
-  target.backend.getIdTokenResultFor(user.uid, claims, true);
-  const refreshed = stored ? target.backend.buildUserFromStored(stored) : user;
+  target.backend.getIdTokenResultFor(user.uid, claims, true, user.tenantId);
+  const hasStoredUser = stored !== undefined;
+  const refreshed = hasStoredUser ? target.backend.buildUserFromStored(stored) : user;
   return {
     user: refreshed,
     providerId,

package/src/auth/sandbox/default-avatar.ts

@@ -0,0 +1,177 @@
+/**
+ * Deterministic default-avatar generation: seed hashing + inline SVG data URI,
+ * plus the mint hook the sandbox backend calls when it creates a
+ * provider-identity record with no photo of its own.
+ */
+
+const FNV_OFFSET_BASIS_A = 0x811c9dc5;
+const FNV_OFFSET_BASIS_B = 0x9e3779b9;
+const FNV_PRIME = 0x01000193;
+
+function fnv1a32(bytes: Uint8Array, offsetBasis: number): number {
+  let hash = offsetBasis;
+  for (let i = 0; i < bytes.length; i++) {
+    hash ^= bytes[i]!;
+    hash = Math.imul(hash, FNV_PRIME);
+  }
+  return hash >>> 0;
+}
+
+function toHex8(value: number): string {
+  return value.toString(16).padStart(8, '0');
+}
+
+/**
+ * Deterministic 64-bit seed for a uid, returned as 16 lowercase hex chars.
+ * FNV-1a 32-bit is run twice with different offset baskets (forward and
+ * reversed uid bytes) to spread the uid's entropy across both halves.
+ */
+export function avatarSeed(uid: string): string {
+  const forwardBytes = new TextEncoder().encode(uid);
+  const reversedBytes = new TextEncoder().encode([...uid].reverse().join(''));
+  const highHalf = fnv1a32(forwardBytes, FNV_OFFSET_BASIS_A);
+  const lowHalf = fnv1a32(reversedBytes, FNV_OFFSET_BASIS_B);
+  return toHex8(highHalf) + toHex8(lowHalf);
+}
+
+interface DefaultAvatarInput {
+  uid: string;
+  displayName?: string | null;
+  email?: string | null;
+  /** Render the generating state: the same deterministic artwork plus a
+   *  spinning ring, with the initial dimmed. A configured source producing
+   *  this user's real image is still running, so the plain avatar would
+   *  otherwise be indistinguishable from a finished one and read as a
+   *  silent failure. Declarative SVG animation, so it runs inside an
+   *  `<img>` element with no script and nothing for an application to
+   *  style. */
+  pending?: boolean;
+}
+
+interface GradientHues {
+  hueStart: number;
+  hueEnd: number;
+  saturation: number;
+  lightness: number;
+}
+
+function gradientHuesFromSeed(seed: string): GradientHues {
+  const highHalf = Number.parseInt(seed.slice(0, 8), 16);
+  const lowHalf = Number.parseInt(seed.slice(8, 16), 16);
+  const hueStart = highHalf % 360;
+  const hueSpread = 40 + (lowHalf % 80);
+  const hueEnd = (hueStart + hueSpread) % 360;
+  const saturation = 60 + (highHalf % 16); // 60-75
+  const lightness = 45 + (lowHalf % 16); // 45-60
+  return { hueStart, hueEnd, saturation, lightness };
+}
+
+/** First Unicode code point of a string, safe for surrogate pairs (emoji, CJK). */
+function firstCodePoint(value: string): string | undefined {
+  const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+  const first = segmenter.segment(value)[Symbol.iterator]().next();
+  if (first.done) return undefined;
+  return first.value.segment;
+}
+
+function glyphFromInput(input: DefaultAvatarInput): string | undefined {
+  const displayNameFirst = input.displayName?.trim();
+  if (displayNameFirst) {
+    const glyph = firstCodePoint(displayNameFirst);
+    if (glyph) return glyph.toUpperCase();
+  }
+  const emailLocalPart = input.email?.split('@')[0]?.trim();
+  if (emailLocalPart) {
+    const glyph = firstCodePoint(emailLocalPart);
+    if (glyph) return glyph.toUpperCase();
+  }
+  return undefined;
+}
+
+/** Encode SVG markup for embedding as a `data:image/svg+xml,` URI. */
+function encodeSvgForDataUri(svg: string): string {
+  return encodeURIComponent(svg)
+    .replace(/'/g, '%27')
+    .replace(/\(/g, '%28')
+    .replace(/\)/g, '%29');
+}
+
+/**
+ * Deterministic default avatar for a user: a two-hue linear gradient plus a
+ * centred initial glyph, as raw SVG markup. `defaultAvatarDataUri` encodes
+ * this for the in-page fallback; the served dev server encodes it as UTF-8
+ * bytes and serves it directly as `image/svg+xml` (the asset resolver's
+ * built-in fallback — see `pyric/auth/internal` and
+ * `@pyric/cli`'s `serve/sandbox-session.ts`).
+ */
+export function defaultAvatarSvg(input: DefaultAvatarInput): string {
+  const seed = avatarSeed(input.uid);
+  const { hueStart, hueEnd, saturation, lightness } = gradientHuesFromSeed(seed);
+  const gradientId = `g${seed}`;
+  const glyph = glyphFromInput(input);
+
+  const pending = input.pending === true;
+
+  const glyphMarkup =
+    glyph === undefined
+      ? ''
+      : `<text x="64" y="64" font-family="system-ui, -apple-system, sans-serif" ` +
+        `font-size="56" fill="#fff" fill-opacity="${pending ? '0.55' : '0.9'}" text-anchor="middle" ` +
+        `dominant-baseline="central">${glyph}</text>`;
+
+  // r=56 with a 6-wide stroke stays inside the 64 radius a circular crop
+  // cuts at, so the ring survives `border-radius: 50%`. The dash pattern
+  // sums to the circumference (2*pi*56), leaving one visible arc.
+  const pendingMarkup = pending
+    ? `<circle cx="64" cy="64" r="56" fill="none" stroke="#fff" stroke-opacity="0.25" stroke-width="6"/>` +
+      `<circle cx="64" cy="64" r="56" fill="none" stroke="#fff" stroke-opacity="0.95" stroke-width="6" ` +
+      `stroke-linecap="round" stroke-dasharray="44 308">` +
+      `<animateTransform attributeName="transform" type="rotate" from="0 64 64" to="360 64 64" ` +
+      `dur="1s" repeatCount="indefinite"/></circle>`
+    : '';
+
+  return (
+    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 128 128">` +
+    `<defs><linearGradient id="${gradientId}" x1="0" y1="0" x2="1" y2="1">` +
+    `<stop offset="0%" stop-color="hsl(${hueStart},${saturation}%,${lightness}%)"/>` +
+    `<stop offset="100%" stop-color="hsl(${hueEnd},${saturation}%,${lightness}%)"/>` +
+    `</linearGradient></defs>` +
+    `<rect width="128" height="128" fill="url(#${gradientId})"/>` +
+    `${glyphMarkup}${pendingMarkup}</svg>`
+  );
+}
+
+/**
+ * Deterministic default avatar for a user, encoded as a `data:image/svg+xml,`
+ * URI — the in-page fallback used when no dev server is present.
+ */
+export function defaultAvatarDataUri(input: DefaultAvatarInput): string {
+  return `data:image/svg+xml,${encodeSvgForDataUri(defaultAvatarSvg(input))}`;
+}
+
+/** Everything a mint knows about the record being created. The provider id is
+ *  the one the record is created under, so a mint can vary the image by
+ *  provider or refuse a provider outright. */
+export interface AvatarMintInput {
+  uid: string;
+  displayName: string | null;
+  email: string | null;
+  providerId: string;
+}
+
+/**
+ * Assigns the `photoURL` a provider-created sandbox user is born with, or
+ * `null` for none. The backend calls it once, at record creation, and stores
+ * whatever it returns — the value is persisted, exported, and captured, so a
+ * mint must be deterministic in its input.
+ *
+ * Three mints exist. {@link defaultAvatarMint} is the built-in and needs no
+ * server. A served host replaces it with one that returns its
+ * `/__pyric/assets/avatar/<uid>` route, and a host with avatars disabled
+ * replaces it with one that returns `null` (Firebase's own behaviour when a
+ * provider supplies no photo).
+ */
+export type AvatarMint = (input: AvatarMintInput) => string | null;
+
+/** The no-server mint: a deterministic SVG data URI, resolvable anywhere. */
+export const defaultAvatarMint: AvatarMint = (input) => defaultAvatarDataUri(input);

package/src/auth/sandbox/driver.ts

@@ -11,6 +11,7 @@ import type {
   UpdateUserRequest,
 } from '../sandbox-backend.js';
 import { targetOf, type SandboxTarget } from '../target.js';
+import type { AvatarMint } from './default-avatar.js';
 import type {
   Auth,
   AuthFlowResolver,
@@ -84,10 +85,34 @@ export const sandbox = {
     return requireSandbox(auth).backend.restoreSession(uid);
   },
 
+  /** Read `Auth.tenantId` without going through the handle's own property,
+   *  for a host capturing the tenant scope alongside a signed-in uid (a
+   *  process boundary has no live `Auth` object to read it from later). */
+  getTenantId(auth: Auth): string | null {
+    return requireSandbox(auth).backend.getTenantId();
+  },
+
+  /** Write `Auth.tenantId` without a sign-in, the seam a host uses to put
+   *  a captured tenant scope back once {@link restoreSession} has restored
+   *  the uid it was captured alongside. */
+  setTenantId(auth: Auth, tenantId: string | null): void {
+    requireSandbox(auth).backend.setTenantId(tenantId);
+  },
+
   mintSession(auth: Auth, request: MintSessionRequest): MintedSession {
     return requireSandbox(auth).backend.mintDetachedSession(request);
   },
 
+  /**
+   * The provider the app session signed in through: `password`, `anonymous`,
+   * `custom`, or a federated provider id such as `google.com`.
+   * The same value `IdTokenResult.signInProvider` carries, so a reporter that
+   * labels a session keeps no second copy of it. `null` when signed out.
+   */
+  signInProvider(auth: Auth): string | null {
+    return requireSandbox(auth).backend.getCurrentSignInProvider();
+  },
+
   listUsers(auth: Auth): AuthUserRecord[] {
     return requireSandbox(auth).backend.listUsers();
   },
@@ -120,6 +145,23 @@ export const sandbox = {
     return requireSandbox(auth).backend.subscribeUsers(callback);
   },
 
+  /**
+   * Which sign-in providers are enabled, keyed by provider id.
+   *
+   * The whole-state form, beside {@link getAuthProviderConfig}'s listing: it
+   * is what a capture writes down and what {@link restoreProviderConfig} takes
+   * back, so a state capture reaches the account store through this namespace
+   * rather than through the backend handle.
+   */
+  exportProviderConfig(auth: Auth): Record<string, boolean> {
+    return requireSandbox(auth).backend.exportProviderConfig();
+  },
+
+  /** Replace the provider configuration with exactly the one given. */
+  restoreProviderConfig(auth: Auth, config: Record<string, boolean>): void {
+    requireSandbox(auth).backend.restoreProviderConfig(config);
+  },
+
   getAuthProviderConfig(auth: Auth): Array<{ providerId: string; enabled: boolean }> {
     return requireSandbox(auth).backend.listProviderConfig();
   },
@@ -136,6 +178,18 @@ export const sandbox = {
     requireSandbox(auth).backend.setProviderEnforcementDelegated(delegated);
   },
 
+  /**
+   * Replace the mint that assigns a default `photoURL` to federated-provider
+   * users at creation. The built-in mint returns a deterministic SVG data URI;
+   * a served host installs one that returns its avatar route, and a host with
+   * avatars turned off installs `() => null` for Firebase's own no-photo
+   * behaviour. Install it during boot: the minted value is stored on each
+   * record as it is created.
+   */
+  setAvatarMint(auth: Auth, mint: AvatarMint): void {
+    requireSandbox(auth).backend.setAvatarMint(mint);
+  },
+
   subscribeAuthProviderConfig(auth: Auth, callback: () => void): Unsubscribe {
     return requireSandbox(auth).backend.subscribeProviderConfig(callback);
   },

package/src/auth/sandbox/project-store.ts

@@ -9,7 +9,6 @@ export interface AuthProjectStore {
   readonly providerConfigSubscribers: Set<() => void>;
   readonly counters: {
     nextAdminUserId: number;
-    nextAnonymousId: number;
   };
 }
 
@@ -25,7 +24,6 @@ export function createAuthProjectStore(): AuthProjectStore {
     providerConfigSubscribers: new Set(),
     counters: {
       nextAdminUserId: 1,
-      nextAnonymousId: 1,
     },
   };
 }