@pyric/cli 0.1.0-alpha.30.2 → 0.1.0-alpha.31

package/src/bridge/surface/arguments/sandbox.ts

@@ -2,11 +2,8 @@
  * The `sandbox` tool's argument vocabulary: the names, shapes, and reads of the
  * project directory that more than one of its methods needs.
  *
- * `seed` is the one method here with nested arguments, and its user entries are
- * where the Admin SDK naming gap reappears: `auth.createUser` already rejects
- * `claims` and `tenant` in favor of `customClaims` and `tenantId`, and a seed
- * that quietly dropped them would leave the tenant or the claim out of the
- * sandbox with nothing said.
+ * The seed entries live in `./seed.ts`, apart from these reads of the project
+ * directory, so the records that take them can run where the sandbox lives.
  *
  * The branch methods share more than a schema. Six of them name a branch, four
  * have to say the same thing when the project holds no branch by that name, and
@@ -22,70 +19,6 @@ import { CAPTURE_RELATIVE_PATH } from '../../../serve/capture-store.js';
 import { z } from 'zod';
 
 import type { Args, Fail, InvalidArguments } from '../method-types.js';
-import { closest, quoted } from '../closest-name.js';
-
-/** The fields a `seed` users entry accepts, after the Admin SDK rename. */
-const USER_FIELDS = ['uid', 'email', 'password', 'customClaims', 'tenantId'] as const;
-
-/** Client SDK spellings of the two user fields the Admin SDK names differently. */
-const USER_FIELD_RENAMES: Readonly<Record<string, string>> = {
-  claims: 'customClaims',
-  tenant: 'tenantId',
-};
-
-/**
- * One seeded user, under the Admin SDK field names. `auth.importUsers` takes
- * the same entry, so an import and a seed describe an identity one way.
- */
-export const userSeed = z.object({
-  uid: z.string().describe('The user id.'),
-  email: z.string().optional().describe('Email address. Generated when omitted.'),
-  password: z
-    .string()
-    .optional()
-    .describe('Password the identity can sign in with. Derived from the uid when omitted.'),
-  customClaims: z.record(z.unknown()).optional().describe('Custom claims on the record.'),
-  tenantId: z.string().optional().describe('Identity Platform tenant the record belongs to.'),
-});
-
-/** One seeded storage object. */
-export const storageObjectSeed = z.object({
-  path: z.string(),
-  contentBase64: z.string(),
-  contentType: z.string().optional(),
-  customMetadata: z.record(z.string()).optional(),
-});
-
-/**
- * Reject a `users` entry field the schema does not declare. The seed schema
- * strips unknown keys rather than failing on them, so this walks the raw
- * arguments a client sent, not the parsed result, the same way the shared
- * validator walks a method's top-level arguments.
- */
-export function checkUserFields(args: Args, fail: Fail): InvalidArguments | null {
-  const users = args.users;
-  if (!Array.isArray(users)) return null;
-  for (const user of users) {
-    if (user === null || typeof user !== 'object' || Array.isArray(user)) continue;
-    for (const name of Object.keys(user as Record<string, unknown>)) {
-      if ((USER_FIELDS as readonly string[]).includes(name)) continue;
-      const renamed = USER_FIELD_RENAMES[name] ?? closest(name, [...USER_FIELDS]);
-      if (renamed !== null && renamed !== undefined) {
-        return fail(
-          `users entry has unknown field ${quoted(name)}. seed names this field ${quoted(renamed)}.`,
-          `Pass '${renamed}' instead of '${name}' in the users entry.`,
-          `users.${name}`,
-        );
-      }
-      return fail(
-        `users entry has unknown field ${quoted(name)}. A users entry accepts ${USER_FIELDS.join(', ')}.`,
-        `Remove '${name}' from the users entry.`,
-        `users.${name}`,
-      );
-    }
-  }
-  return null;
-}
 
 /** The value of `against` that names the live sandbox rather than a checkpoint. */
 export const AGAINST_LIVE = 'live';

package/src/bridge/surface/arguments/seed.ts

@@ -0,0 +1,78 @@
+/**
+ * The seed entry vocabulary `sandbox.seed` and `auth.importUsers` share.
+ *
+ * A users entry is where the Admin SDK naming gap reappears: `auth.createUser`
+ * already rejects `claims` and `tenant` in favor of `customClaims` and
+ * `tenantId`, and a seed that quietly dropped them would leave the tenant or
+ * the claim out of the sandbox with nothing said.
+ *
+ * Nothing here reads the project directory, so both records can run where the
+ * sandbox lives.
+ */
+import { z } from 'zod';
+
+import type { Args, Fail, InvalidArguments } from '../method-types.js';
+import { closest, quoted } from '../closest-name.js';
+
+/** The fields a `seed` users entry accepts, after the Admin SDK rename. */
+const USER_FIELDS = ['uid', 'email', 'password', 'customClaims', 'tenantId'] as const;
+
+/** Client SDK spellings of the two user fields the Admin SDK names differently. */
+const USER_FIELD_RENAMES: Readonly<Record<string, string>> = {
+  claims: 'customClaims',
+  tenant: 'tenantId',
+};
+
+/**
+ * One seeded user, under the Admin SDK field names. `auth.importUsers` takes
+ * the same entry, so an import and a seed describe an identity one way.
+ */
+export const userSeed = z.object({
+  uid: z.string().describe('The user id.'),
+  email: z.string().optional().describe('Email address. Generated when omitted.'),
+  password: z
+    .string()
+    .optional()
+    .describe('Password the identity can sign in with. Derived from the uid when omitted.'),
+  customClaims: z.record(z.unknown()).optional().describe('Custom claims on the record.'),
+  tenantId: z.string().optional().describe('Identity Platform tenant the record belongs to.'),
+});
+
+/** One seeded storage object. */
+export const storageObjectSeed = z.object({
+  path: z.string(),
+  contentBase64: z.string(),
+  contentType: z.string().optional(),
+  customMetadata: z.record(z.string()).optional(),
+});
+
+/**
+ * Reject a `users` entry field the schema does not declare. The seed schema
+ * strips unknown keys rather than failing on them, so this walks the raw
+ * arguments a client sent, not the parsed result, the same way the shared
+ * validator walks a method's top-level arguments.
+ */
+export function checkUserFields(args: Args, fail: Fail): InvalidArguments | null {
+  const users = args.users;
+  if (!Array.isArray(users)) return null;
+  for (const user of users) {
+    if (user === null || typeof user !== 'object' || Array.isArray(user)) continue;
+    for (const name of Object.keys(user as Record<string, unknown>)) {
+      if ((USER_FIELDS as readonly string[]).includes(name)) continue;
+      const renamed = USER_FIELD_RENAMES[name] ?? closest(name, [...USER_FIELDS]);
+      if (renamed !== null && renamed !== undefined) {
+        return fail(
+          `users entry has unknown field ${quoted(name)}. seed names this field ${quoted(renamed)}.`,
+          `Pass '${renamed}' instead of '${name}' in the users entry.`,
+          `users.${name}`,
+        );
+      }
+      return fail(
+        `users entry has unknown field ${quoted(name)}. A users entry accepts ${USER_FIELDS.join(', ')}.`,
+        `Remove '${name}' from the users entry.`,
+        `users.${name}`,
+      );
+    }
+  }
+  return null;
+}

package/src/bridge/surface/context.ts

@@ -1,21 +1,25 @@
 /**
- * The execution context every rendered tool hands its operation handler.
+ * The execution context every rendered tool hands its operation handler in
+ * the bridge process.
  *
- * One context per sandbox. Its dispatcher is the union of the two halves of
- * the default surface: the forwarded families through the shared
- * `buildSandboxDispatcher`, and the in-process families (the rules engine and
- * the stdlib catalogue) through their own handlers. An operation that maps
- * onto an existing tool therefore executes exactly the code path that tool
- * always did, whichever half it lives in.
+ * One context per sandbox. It widens the sandbox context (`./sandbox-context.ts`)
+ * with the project directory and the in-process tool families. Its dispatcher
+ * is the union of the two halves of the default surface: the forwarded families
+ * through the shared `buildSandboxDispatcher`, and the in-process families (the
+ * rules engine and the stdlib catalogue) through their own handlers. An
+ * operation that maps onto an existing tool therefore executes exactly the code
+ * path that tool always did, whichever half it lives in.
  */
 import type { ToolHandler } from 'pyric/sandbox/internal';
 import type { LocalSandbox } from 'pyric/sandbox';
 import type { CheckpointBackend } from 'pyric/sandbox/checkpoints';
-import { buildSandboxDispatcher, type SandboxDispatch } from '../client/dispatch.js';
+import type { SandboxDispatch } from '../client/dispatch.js';
 import { getInProcessToolHandlers } from '../server/tool-metadata.js';
-import { accountLookupFor } from './app-session.js';
-import { SurfaceIdentity } from './identity.js';
-import type { OperationResult, SurfaceContext } from './types.js';
+import { projectDatabaseInstances } from './database-instance-project.js';
+import { createSandboxSurfaceContext } from './sandbox-context.js';
+import type { SurfaceContext, SurfaceTargetRouter } from './types.js';
+
+export { callSandboxTool, operationFailure } from './sandbox-context.js';
 
 /** The minimal tool context the in-process handlers read. */
 function handlerContext(): never {
@@ -23,8 +27,7 @@ function handlerContext(): never {
 }
 
 /** A dispatcher over both halves of the default tool surface. */
-function buildSurfaceDispatch(sandbox: LocalSandbox): SandboxDispatch {
-  const forwarded = buildSandboxDispatcher(sandbox);
+function withInProcessFamilies(forwarded: SandboxDispatch): SandboxDispatch {
   const inProcess = new Map<string, ToolHandler>(
     getInProcessToolHandlers().map((handler) => [handler.name, handler]),
   );
@@ -41,38 +44,24 @@ function buildSurfaceDispatch(sandbox: LocalSandbox): SandboxDispatch {
  * session's `.pyric/` files live under; it defaults to the process working
  * directory, which is what a caller that never leaves its own project gets.
  * `checkpoints` is where the host keeps checkpoints when it is not that
- * directory.
+ * directory. The RTDB instances are read from the project's files on each
+ * call, unless a host replaces `databaseInstances` with its own.
  */
 export function createSurfaceContext(
   sandbox: LocalSandbox,
   projectDir: string = process.cwd(),
-  targetRouter?: import('./types.js').SurfaceTargetRouter,
+  targetRouter?: SurfaceTargetRouter,
   checkpoints?: CheckpointBackend,
 ): SurfaceContext {
-  return {
-    sandbox,
-    dispatch: buildSurfaceDispatch(sandbox),
-    identity: new SurfaceIdentity(accountLookupFor(sandbox)),
+  const base = createSandboxSurfaceContext(sandbox, () =>
+    projectDatabaseInstances(context.sandbox, context.projectDir),
+  );
+  const context: SurfaceContext = {
+    ...base,
+    dispatch: withInProcessFamilies(base.dispatch),
     projectDir,
     targetRouter,
     checkpoints,
   };
-}
-
-/**
- * Call one existing sandbox tool under the held identity. Arguments are
- * objects in and objects out; nothing is JSON-encoded on the way through.
- */
-export async function callSandboxTool(
-  ctx: SurfaceContext,
-  name: string,
-  args: Record<string, unknown>,
-): Promise<OperationResult> {
-  return ctx.dispatch(name, args, ctx.identity.lens());
-}
-
-/** Report a failure in the shape every handler returns. */
-export function operationFailure(summary: string, data?: unknown): OperationResult {
-  if (data === undefined) return { ok: false, summary };
-  return { ok: false, summary, data };
+  return context;
 }

package/src/bridge/surface/database-instance-catalog.ts

@@ -3,18 +3,12 @@
  *
  * An instance is known when `firebase.json` declares it or the sandbox already
  * holds data for it, because an app can open an instance `firebase.json` never
- * names. The Node host builds its catalog from the instances it serves
+ * names. A host builds its catalog from the instances it serves
  * (`serve/worker/host/rtdb-instance-catalog.ts`); the in-process sandbox and
- * the CLI runner read the project's files here.
+ * the CLI runner read the project's files (`./database-instance-project.ts`).
+ * This module reads no files, so a host in a browser can import it.
  */
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { heldDatabaseInstances } from 'pyric/database/internal';
-import { UNNAMED_DEFAULT_DATABASE_INSTANCE, isDefaultDatabaseInstance } from 'pyric/sandbox/internal';
-import type { LocalSandbox } from 'pyric/sandbox';
-import { readFirebaseJson } from '../../cli/firebase-json.js';
-import { resolveFirebaseProject } from '../../cli/firebase-project.js';
-import { databaseRulesTargets } from '../../serve/rules.js';
+import { isDefaultDatabaseInstance } from 'pyric/sandbox/internal';
 
 /** The instances a caller may name, as the refusal lists them. */
 export interface KnownDatabaseInstances {
@@ -55,25 +49,3 @@ export function databaseInstanceCatalog(known: KnownDatabaseInstances, projectId
 export function distinctNames(names: readonly string[], exclude: string | undefined): string[] {
   return [...new Set(names)].filter((name) => name !== exclude);
 }
-
-/** The catalog for a project directory: its `firebase.json`, its project, and what `sandbox` holds. */
-export async function projectDatabaseInstances(
-  sandbox: LocalSandbox,
-  projectDir: string,
-): Promise<DatabaseInstanceCatalog> {
-  const hasFirebaseJson = existsSync(join(projectDir, 'firebase.json'));
-  const config = hasFirebaseJson ? await readFirebaseJson(projectDir) : null;
-  const project = resolveFirebaseProject({ projectDir });
-  const targets = databaseRulesTargets(projectDir, config, project);
-  const isNamed = targets.defaultInstance !== UNNAMED_DEFAULT_DATABASE_INSTANCE;
-  const defaultInstance = isNamed ? targets.defaultInstance : undefined;
-  const declared = targets.targets.map((target) => target.instance);
-  const projectId = project.projectId;
-  const named = distinctNames([...declared, ...heldDatabaseInstances(sandbox)], targets.defaultInstance)
-    .filter((name) => !isDefaultDatabaseInstance(name, projectId));
-  return databaseInstanceCatalog({
-    ...(defaultInstance === undefined ? {} : { defaultInstance }),
-    named,
-    pending: targets.pending.map((target) => `${target.label} target "${target.target}" selects no instance yet: ${target.reason}.`),
-  }, projectId);
-}

package/src/bridge/surface/database-instance-project.ts

@@ -0,0 +1,40 @@
+/**
+ * The Realtime Database instances a project directory declares, for the
+ * in-process sandbox and the CLI runner, which have no host to ask. It reads
+ * `firebase.json`, so it runs only in the bridge process.
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { heldDatabaseInstances } from 'pyric/database/internal';
+import { UNNAMED_DEFAULT_DATABASE_INSTANCE, isDefaultDatabaseInstance } from 'pyric/sandbox/internal';
+import type { LocalSandbox } from 'pyric/sandbox';
+import { readFirebaseJson } from '../../cli/firebase-json.js';
+import { resolveFirebaseProject } from '../../cli/firebase-project.js';
+import { databaseRulesTargets } from '../../serve/rules.js';
+import {
+  databaseInstanceCatalog,
+  distinctNames,
+  type DatabaseInstanceCatalog,
+} from './database-instance-catalog.js';
+
+/** The catalog for a project directory: its `firebase.json`, its project, and what `sandbox` holds. */
+export async function projectDatabaseInstances(
+  sandbox: LocalSandbox,
+  projectDir: string,
+): Promise<DatabaseInstanceCatalog> {
+  const hasFirebaseJson = existsSync(join(projectDir, 'firebase.json'));
+  const config = hasFirebaseJson ? await readFirebaseJson(projectDir) : null;
+  const project = resolveFirebaseProject({ projectDir });
+  const targets = databaseRulesTargets(projectDir, config, project);
+  const isNamed = targets.defaultInstance !== UNNAMED_DEFAULT_DATABASE_INSTANCE;
+  const defaultInstance = isNamed ? targets.defaultInstance : undefined;
+  const declared = targets.targets.map((target) => target.instance);
+  const projectId = project.projectId;
+  const named = distinctNames([...declared, ...heldDatabaseInstances(sandbox)], targets.defaultInstance)
+    .filter((name) => !isDefaultDatabaseInstance(name, projectId));
+  return databaseInstanceCatalog({
+    ...(defaultInstance === undefined ? {} : { defaultInstance }),
+    named,
+    pending: targets.pending.map((target) => `${target.label} target "${target.target}" selects no instance yet: ${target.reason}.`),
+  }, projectId);
+}

package/src/bridge/surface/database-instance.ts

@@ -8,8 +8,8 @@
  * a typo would otherwise open an empty instance and read back nothing.
  */
 import { resolveDatabaseInstance } from 'pyric/sandbox/internal';
-import { projectDatabaseInstances, type KnownDatabaseInstances } from './database-instance-catalog.js';
-import type { SurfaceContext } from './types.js';
+import type { KnownDatabaseInstances } from './database-instance-catalog.js';
+import type { SandboxSurfaceContext } from './types.js';
 
 /** The instances listed in a refusal, the default first. */
 function describeKnown(known: KnownDatabaseInstances): string {
@@ -32,11 +32,11 @@ export function unknownInstanceMessage(name: string, known: KnownDatabaseInstanc
  * the default instance, else the instance name. Throws the refusal for an
  * instance the project does not have.
  */
-export async function instanceSelector(ctx: SurfaceContext, raw: unknown): Promise<string | undefined> {
+export async function instanceSelector(ctx: SandboxSurfaceContext, raw: unknown): Promise<string | undefined> {
   if (raw === undefined) return undefined;
   const instance = resolveDatabaseInstance(String(raw));
   if (instance === undefined) return undefined;
-  const catalog = ctx.databaseInstances ?? await projectDatabaseInstances(ctx.sandbox, ctx.projectDir);
+  const catalog = await ctx.databaseInstances();
   const selector = catalog.select(instance.name);
   if (selector === null) throw new Error(unknownInstanceMessage(instance.name, catalog.known()));
   return selector;

package/src/bridge/surface/functions-runtime.ts

@@ -3,7 +3,7 @@
  * runtime from a project directory, rather than each method repeating the
  * "where does this project keep its Functions source" question.
  *
- * `discoverFunctionsRtdbProject` answers three ways: no `firebase.json`, or a
+ * `discoverFunctionsProject` answers three ways: no `firebase.json`, or a
  * `firebase.json` with no `functions` key, both mean the project declares no
  * Functions source and this reports an empty discovery rather than an error;
  * a declared source that does not resolve (a missing directory, a malformed
@@ -14,9 +14,9 @@ import {
   inspectOnValueCreated,
   type DiscoveredOnValueCreated,
   type UnsupportedOnValueCreated,
-} from '../../functions-rtdb/discovery.js';
-import { loadFunctionsModuleExports } from '../../functions-rtdb/module-loader.js';
-import { discoverFunctionsRtdbProject } from '../../functions-rtdb/project.js';
+} from '../../functions/rtdb/discovery.js';
+import { loadFunctionsModuleExports } from '../../functions/module-loader.js';
+import { discoverFunctionsProject } from '../../functions/project.js';
 
 export interface FunctionsDiscovery {
   /** Where this project's Functions source was looked for. */
@@ -28,7 +28,7 @@ export interface FunctionsDiscovery {
 /** Discover the RTDB triggers one project's Functions source defines, if it has one. */
 export async function discoverFunctionsTriggers(projectDir: string): Promise<FunctionsDiscovery> {
   const lookedAt = `${projectDir}/firebase.json`;
-  const project = discoverFunctionsRtdbProject(projectDir);
+  const project = discoverFunctionsProject(projectDir);
   if (project === null) return { lookedAt, triggers: [], unsupported: [] };
   const exported = await loadFunctionsModuleExports(project.entry);
   const inspected = inspectOnValueCreated(exported);

package/src/bridge/surface/held-identity.ts

@@ -15,7 +15,7 @@
  */
 import { describeAppSession, readAppSession } from './app-session.js';
 import type { IdentityInput } from './identity.js';
-import type { OperationResult, SurfaceContext } from './types.js';
+import type { OperationResult, SandboxSurfaceContext } from './types.js';
 
 /**
  * One line naming the agent identity.
@@ -44,7 +44,7 @@ function reported(held: { mode: string; uid?: string }): OperationResult {
 }
 
 /** Set the identity every later call runs under, and report it. */
-export function switchHeldIdentity(ctx: SurfaceContext, input: IdentityInput): OperationResult {
+export function switchHeldIdentity(ctx: SandboxSurfaceContext, input: IdentityInput): OperationResult {
   return reported(ctx.identity.switchTo(input));
 }
 
@@ -68,7 +68,7 @@ export interface HeldSession {
  * `--target` takes. These two are neither of those: they are the identities
  * this process itself holds.
  */
-export function listHeldSessions(ctx: SurfaceContext): OperationResult {
+export function listHeldSessions(ctx: SandboxSurfaceContext): OperationResult {
   const agent = ctx.identity.describe();
   const appSession = readAppSession(ctx.sandbox);
 
@@ -101,7 +101,7 @@ export function listHeldSessions(ctx: SurfaceContext): OperationResult {
  * identity, said again in one phrase, because that is the question a caller
  * asks this method to answer.
  */
-export function describeBothIdentities(ctx: SurfaceContext): OperationResult {
+export function describeBothIdentities(ctx: SandboxSurfaceContext): OperationResult {
   const agent = ctx.identity.describe();
   const appSession = readAppSession(ctx.sandbox);
   const runsAs = describeAgentIdentity(agent);

package/src/bridge/surface/manifest.sandbox.generated.ts

@@ -0,0 +1,137 @@
+// Generated by scripts/generate-surface-manifest.ts. Do not edit.
+import type { SandboxMethodRecord } from './method-types.js';
+import aiLogicClearScripts from './methods/ai_logic/clearScripts.js';
+import aiLogicScript from './methods/ai_logic/script.js';
+import aiLogicScripts from './methods/ai_logic/scripts.js';
+import aiLogicStatus from './methods/ai_logic/status.js';
+import authActAsAdmin from './methods/auth/actAsAdmin.js';
+import authActAsAnonymous from './methods/auth/actAsAnonymous.js';
+import authCreateCustomToken from './methods/auth/createCustomToken.js';
+import authCreateUser from './methods/auth/createUser.js';
+import authDeleteUser from './methods/auth/deleteUser.js';
+import authGetUser from './methods/auth/getUser.js';
+import authGetUserByEmail from './methods/auth/getUserByEmail.js';
+import authImpersonate from './methods/auth/impersonate.js';
+import authImportUsers from './methods/auth/importUsers.js';
+import authListUsers from './methods/auth/listUsers.js';
+import authSessions from './methods/auth/sessions.js';
+import authSetCustomUserClaims from './methods/auth/setCustomUserClaims.js';
+import authSignInAnonymously from './methods/auth/signInAnonymously.js';
+import authSignInWithCredential from './methods/auth/signInWithCredential.js';
+import authSignInWithCustomToken from './methods/auth/signInWithCustomToken.js';
+import authSignInWithEmailAndPassword from './methods/auth/signInWithEmailAndPassword.js';
+import authSignOut from './methods/auth/signOut.js';
+import authTakeAuthMail from './methods/auth/takeAuthMail.js';
+import authUpdateUser from './methods/auth/updateUser.js';
+import authUseAppSession from './methods/auth/useAppSession.js';
+import authWhoami from './methods/auth/whoami.js';
+import databaseCrawl from './methods/database/crawl.js';
+import databaseGet from './methods/database/get.js';
+import databasePush from './methods/database/push.js';
+import databaseQuery from './methods/database/query.js';
+import databaseRemove from './methods/database/remove.js';
+import databaseSet from './methods/database/set.js';
+import databaseUpdate from './methods/database/update.js';
+import firestoreAddDoc from './methods/firestore/addDoc.js';
+import firestoreDeleteDoc from './methods/firestore/deleteDoc.js';
+import firestoreDiscoverPaths from './methods/firestore/discoverPaths.js';
+import firestoreExtractIndexes from './methods/firestore/extractIndexes.js';
+import firestoreFindCollectionGroup from './methods/firestore/findCollectionGroup.js';
+import firestoreGetAggregateFromServer from './methods/firestore/getAggregateFromServer.js';
+import firestoreGetCountFromServer from './methods/firestore/getCountFromServer.js';
+import firestoreGetDoc from './methods/firestore/getDoc.js';
+import firestoreGetDocs from './methods/firestore/getDocs.js';
+import firestoreSetDoc from './methods/firestore/setDoc.js';
+import firestoreUpdateDoc from './methods/firestore/updateDoc.js';
+import firestoreWriteBatch from './methods/firestore/writeBatch.js';
+import functionsExecutions from './methods/functions/executions.js';
+import messagingDeliveries from './methods/messaging/deliveries.js';
+import messagingSend from './methods/messaging/send.js';
+import messagingSubscribeToTopic from './methods/messaging/subscribeToTopic.js';
+import messagingTokens from './methods/messaging/tokens.js';
+import messagingUnsubscribeFromTopic from './methods/messaging/unsubscribeFromTopic.js';
+import sandboxActivity from './methods/sandbox/activity.js';
+import sandboxAdvanceClock from './methods/sandbox/advanceClock.js';
+import sandboxEvents from './methods/sandbox/events.js';
+import sandboxInspect from './methods/sandbox/inspect.js';
+import sandboxListeners from './methods/sandbox/listeners.js';
+import sandboxReset from './methods/sandbox/reset.js';
+import sandboxResetClock from './methods/sandbox/resetClock.js';
+import sandboxSeed from './methods/sandbox/seed.js';
+import sandboxSetClock from './methods/sandbox/setClock.js';
+import storageDeleteObject from './methods/storage/deleteObject.js';
+import storageGetBytes from './methods/storage/getBytes.js';
+import storageGetDownloadURL from './methods/storage/getDownloadURL.js';
+import storageGetMetadata from './methods/storage/getMetadata.js';
+import storageListAll from './methods/storage/listAll.js';
+import storageSetCrossServiceIam from './methods/storage/setCrossServiceIam.js';
+import storageUpdateMetadata from './methods/storage/updateMetadata.js';
+
+export const SANDBOX_METHOD_RECORDS: ReadonlyArray<readonly [string, string, SandboxMethodRecord]> = [
+  ['ai_logic', 'clearScripts', aiLogicClearScripts],
+  ['ai_logic', 'script', aiLogicScript],
+  ['ai_logic', 'scripts', aiLogicScripts],
+  ['ai_logic', 'status', aiLogicStatus],
+  ['auth', 'actAsAdmin', authActAsAdmin],
+  ['auth', 'actAsAnonymous', authActAsAnonymous],
+  ['auth', 'createCustomToken', authCreateCustomToken],
+  ['auth', 'createUser', authCreateUser],
+  ['auth', 'deleteUser', authDeleteUser],
+  ['auth', 'getUser', authGetUser],
+  ['auth', 'getUserByEmail', authGetUserByEmail],
+  ['auth', 'impersonate', authImpersonate],
+  ['auth', 'importUsers', authImportUsers],
+  ['auth', 'listUsers', authListUsers],
+  ['auth', 'sessions', authSessions],
+  ['auth', 'setCustomUserClaims', authSetCustomUserClaims],
+  ['auth', 'signInAnonymously', authSignInAnonymously],
+  ['auth', 'signInWithCredential', authSignInWithCredential],
+  ['auth', 'signInWithCustomToken', authSignInWithCustomToken],
+  ['auth', 'signInWithEmailAndPassword', authSignInWithEmailAndPassword],
+  ['auth', 'signOut', authSignOut],
+  ['auth', 'takeAuthMail', authTakeAuthMail],
+  ['auth', 'updateUser', authUpdateUser],
+  ['auth', 'useAppSession', authUseAppSession],
+  ['auth', 'whoami', authWhoami],
+  ['database', 'crawl', databaseCrawl],
+  ['database', 'get', databaseGet],
+  ['database', 'push', databasePush],
+  ['database', 'query', databaseQuery],
+  ['database', 'remove', databaseRemove],
+  ['database', 'set', databaseSet],
+  ['database', 'update', databaseUpdate],
+  ['firestore', 'addDoc', firestoreAddDoc],
+  ['firestore', 'deleteDoc', firestoreDeleteDoc],
+  ['firestore', 'discoverPaths', firestoreDiscoverPaths],
+  ['firestore', 'extractIndexes', firestoreExtractIndexes],
+  ['firestore', 'findCollectionGroup', firestoreFindCollectionGroup],
+  ['firestore', 'getAggregateFromServer', firestoreGetAggregateFromServer],
+  ['firestore', 'getCountFromServer', firestoreGetCountFromServer],
+  ['firestore', 'getDoc', firestoreGetDoc],
+  ['firestore', 'getDocs', firestoreGetDocs],
+  ['firestore', 'setDoc', firestoreSetDoc],
+  ['firestore', 'updateDoc', firestoreUpdateDoc],
+  ['firestore', 'writeBatch', firestoreWriteBatch],
+  ['functions', 'executions', functionsExecutions],
+  ['messaging', 'deliveries', messagingDeliveries],
+  ['messaging', 'send', messagingSend],
+  ['messaging', 'subscribeToTopic', messagingSubscribeToTopic],
+  ['messaging', 'tokens', messagingTokens],
+  ['messaging', 'unsubscribeFromTopic', messagingUnsubscribeFromTopic],
+  ['sandbox', 'activity', sandboxActivity],
+  ['sandbox', 'advanceClock', sandboxAdvanceClock],
+  ['sandbox', 'events', sandboxEvents],
+  ['sandbox', 'inspect', sandboxInspect],
+  ['sandbox', 'listeners', sandboxListeners],
+  ['sandbox', 'reset', sandboxReset],
+  ['sandbox', 'resetClock', sandboxResetClock],
+  ['sandbox', 'seed', sandboxSeed],
+  ['sandbox', 'setClock', sandboxSetClock],
+  ['storage', 'deleteObject', storageDeleteObject],
+  ['storage', 'getBytes', storageGetBytes],
+  ['storage', 'getDownloadURL', storageGetDownloadURL],
+  ['storage', 'getMetadata', storageGetMetadata],
+  ['storage', 'listAll', storageListAll],
+  ['storage', 'setCrossServiceIam', storageSetCrossServiceIam],
+  ['storage', 'updateMetadata', storageUpdateMetadata],
+];