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

package/src/serve/rules.ts

@@ -12,7 +12,7 @@
 import { createHash } from 'node:crypto';
 import { readFileSync, watch, type FSWatcher } from 'node:fs';
 import { readFile } from 'node:fs/promises';
-import { dirname, isAbsolute, join } from 'node:path';
+import { dirname, isAbsolute, join, relative } from 'node:path';
 import {
   describeCompileLimitViolations,
   lintFirestoreRules,
@@ -21,8 +21,17 @@ import {
   sourceCompileLimitViolations,
   type ResolveResult,
 } from 'pyric/rules/internal';
-import { asSentence, databaseRulesConfig, type DatabaseRulesConfig } from 'pyric/sandbox/internal';
+import {
+  asSentence,
+  databaseRulesConfig,
+  defaultFirestoreDatabase,
+  firestoreRulesConfig,
+  unservedFirestoreDatabaseWarnings,
+  type DatabaseRulesConfig,
+  type FirestoreRulesConfig,
+} from 'pyric/sandbox/internal';
 import { parseStorageRules } from 'pyric/storage';
+import { compileStorageRules } from 'pyric/storage/internal';
 import { readFirebaseRcSync, type FirebaseJson, type FirebaseRc } from '../cli/firebase-json.js';
 import {
   describeFirebaseProject,
@@ -44,6 +53,8 @@ export interface LoadedRules {
   /** Rules files of the project's own that the source imports, directly or
    *  through other modules. Watched alongside `sourcePath`. */
   moduleFiles: string[];
+  /** One line per `firebase.json` Firestore entry pyric does not serve yet. */
+  warnings: string[];
 }
 
 export interface LoadedStorageRules {
@@ -139,9 +150,16 @@ export function prepareProjectRules(raw: string, sourcePath: string): PreparedRu
     source = resolved.data.resolved;
   }
   // Production rejects a ruleset that does not parse, or is past its compile
-  // limits, before it evaluates any request, so the sandbox does not serve
-  // one either: the check every rules load path runs.
+  // limits, or names a service other than cloud.firestore, before it
+  // evaluates any request, so the sandbox does not serve one either: the
+  // check every rules load path runs, with the reason every plane gives.
   const rejection = rulesSourceRejection(source);
+  if (rejection?.kind === 'parse' && rejection.otherService !== undefined) {
+    throw new RulesPrepareError(
+      `pyric sandbox: ${sourcePath}: Firestore ${rejection.message} Fix the rules before serving.`,
+      moduleFiles,
+    );
+  }
   if (rejection?.kind === 'parse') {
     throw new RulesPrepareError(
       `pyric sandbox: ${sourcePath} failed to parse (line ${rejection.line}, col ${rejection.column}). Fix the rules before serving.`,
@@ -167,47 +185,107 @@ export function prepareProjectRules(raw: string, sourcePath: string): PreparedRu
 }
 
 /**
- * The Firestore rules file the project deploys: `firebase.json`'s
- * `firestore.rules`, else `firestore.rules` in `cwd`. The file may not exist.
+ * Where a project's Firestore deploy targets resolve from: the project id
+ * and `.firebaserc`. Without a project id, target entries stay unresolved.
  */
-export function firestoreRulesPath(cwd: string, config: FirebaseJson | null): string {
-  const rel = config?.firestore?.rules ?? 'firestore.rules';
-  return isAbsolute(rel) ? rel : join(cwd, rel);
+export interface FirestoreRulesProject {
+  projectId?: string;
+  /** Reads `.firebaserc`. Defaults to reading it from the project directory. */
+  readRc?: () => FirebaseRc | null;
 }
 
 /**
- * Load the project rules per `firebase.json` (`firestore.rules` path,
- * defaulting to `firestore.rules` in cwd when the key is absent but the file
- * exists). Missing file with no explicit config → `{ rules: null }` (serving
- * without rules is fine; the runtime logs it). Missing file that IS
- * explicitly configured → throw (the project says it should exist).
+ * The Firestore databases `firebase.json` deploys to, resolved by
+ * {@link firestoreRulesConfig} as `firebase deploy` resolves them, with files
+ * as absolute paths.
+ */
+export function firestoreDatabases(
+  cwd: string,
+  config: FirebaseJson | null,
+  project: FirestoreRulesProject = {},
+): FirestoreRulesConfig {
+  const { projectId } = project;
+  const readRc = project.readRc ?? (() => readFirebaseRcSync(cwd));
+  try {
+    return firestoreRulesConfig(config?.firestore, {
+      targetDatabases: (target) => projectId === undefined ? [] : readRc()?.targets?.[projectId]?.firestore?.[target] ?? [],
+      resolveFile: (file) => isAbsolute(file) ? file : join(cwd, file),
+    });
+  } catch (error) {
+    throw new Error(`pyric sandbox: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+/**
+ * The rules file `firebase.json` deploys to the `(default)` Firestore
+ * database, else `firestore.rules` in `cwd` when `firebase.json` names none.
+ * Null when an array form deploys no rules to `(default)`. The file may not
+ * exist.
+ */
+export function firestoreRulesPath(
+  cwd: string,
+  config: FirebaseJson | null,
+  project: FirestoreRulesProject = {},
+): string | null {
+  return defaultFirestoreDatabase(firestoreDatabases(cwd, config, project))?.rulesFile ?? null;
+}
+
+/**
+ * Load the `(default)` database's rules per `firebase.json`, resolved by
+ * {@link firestoreDatabases}. Missing file with no explicit config, or no
+ * rules for `(default)` → `{ rules: null }` (serving without rules is fine;
+ * the runtime logs it). Missing file that IS explicitly configured → throw
+ * (the project says it should exist). `warnings` names each named database
+ * and unresolved target pyric does not serve yet.
  */
 export async function loadProjectRules(
   cwd: string,
   config: FirebaseJson | null,
+  project: FirestoreRulesProject = {},
 ): Promise<LoadedRules> {
-  const configured = config?.firestore?.rules;
-  const path = firestoreRulesPath(cwd, config);
+  const databases = firestoreDatabases(cwd, config, project);
+  const warnings = firestoreDatabaseWarnings(cwd, databases);
+  const entry = defaultFirestoreDatabase(databases);
+  const path = entry?.rulesFile;
+  const none: LoadedRules = { rules: null, rulesHash: null, sourcePath: null, moduleFiles: [], warnings };
+  if (entry === undefined || path === undefined) return none;
   let raw: string;
   try {
     raw = await readFile(path, 'utf8');
   } catch (e) {
     if ((e as NodeJS.ErrnoException).code === 'ENOENT') {
-      if (configured) {
-        throw new Error(`pyric sandbox: firebase.json points firestore.rules at ${path}, but it does not exist.`);
+      if (entry.configured) {
+        throw new Error(`pyric sandbox: ${entry.label} points Firestore rules at ${path}, but it does not exist.`);
       }
-      return { rules: null, rulesHash: null, sourcePath: null, moduleFiles: [] };
+      return none;
     }
     throw e;
   }
   const { rules, moduleFiles } = prepareProjectRules(raw, path);
-  return { rules, rulesHash: rulesHashOf(rules), sourcePath: path, moduleFiles };
+  return { rules, rulesHash: rulesHashOf(rules), sourcePath: path, moduleFiles, warnings };
 }
 
+/** One warning per Firestore database `firebase.json` declares that pyric does not serve yet, files named relative to `cwd`. */
+export function firestoreDatabaseWarnings(cwd: string, databases: FirestoreRulesConfig): string[] {
+  return unservedFirestoreDatabaseWarnings(databases, (file) => relativeToProject(cwd, file));
+}
+
+function relativeToProject(cwd: string, file: string): string {
+  const rel = relative(cwd, file);
+  const isInsideProject = rel !== '' && !rel.startsWith('..') && !isAbsolute(rel);
+  return isInsideProject ? rel : file;
+}
+
+/** `compileStorageRules` opens some of its reasons with this; the message here says it already. */
+const STORAGE_COMPILE_PREFIX = /^Storage rules do not compile: /;
+
 /**
  * Resolve and validate a raw Storage rules source. Modular sources are
  * authored in storage.modules.rules and resolved in memory before the
  * sandbox sees them; firebase.json can continue to point at storage.rules.
+ * The source is checked by the sandbox's own install gate,
+ * `compileStorageRules`, so every source this accepts installs on every
+ * plane, and a reload this refuses is reported as refused.
  */
 export function prepareStorageRulesSource(raw: string, sourcePath: string): string {
   let source = raw;
@@ -233,6 +311,12 @@ export function prepareStorageRulesSource(raw: string, sourcePath: string): stri
       `${asSentence(`pyric sandbox: ${sourcePath} failed to parse: ${e instanceof Error ? e.message : String(e)}`)} Fix the rules before serving.`,
     );
   }
+  try {
+    compileStorageRules(source);
+  } catch (e) {
+    const reason = (e instanceof Error ? e.message : String(e)).replace(STORAGE_COMPILE_PREFIX, '');
+    throw new Error(`${asSentence(`pyric sandbox: ${sourcePath} does not compile: ${reason}`)} Fix the rules before serving.`);
+  }
   return source;
 }
 

package/src/serve/sandbox-session.ts

@@ -43,6 +43,7 @@ import {
 import { restoredStateCounts, stateForSummary } from './state-summary.js';
 import { parseStateFile } from './state-file.js';
 import { inlineStorage } from './state-objects.js';
+import type { AppPorts } from './app-ports.js';
 import { createHostedPersistence, formatStorageRepairs, type HostedPersistence } from './hosted/persistence.js';
 import type { GeminiProxyConfig } from './gemini-proxy.js';
 import {
@@ -53,6 +54,8 @@ import {
 export interface SandboxSessionOptions {
   boundHost?: string;
   allowedHosts?: string[];
+  /** The app's ports under `pyric sandbox` (see `NamespaceOptions.appPorts`). */
+  appPorts?: AppPorts;
   flow?: FlowConfig;
   projectDir: string;
   firebaseConfig: FirebaseJson | null;
@@ -215,7 +218,8 @@ export async function createSandboxSession(
 ): Promise<SandboxSession> {
   // Preserve the established fail-fast order: Firestore, then RTDB, then
   // Storage. Callers historically surfaced the first error in this sequence.
-  const firestore = await loadProjectRules(options.projectDir, options.firebaseConfig);
+  const firestore = await loadProjectRules(options.projectDir, options.firebaseConfig, options.project);
+  for (const warning of firestore.warnings) options.logger?.note(`  ⚠ ${warning}`);
   const database = await loadProjectDatabaseRules(options.projectDir, options.firebaseConfig, options.project);
   const storage = await loadProjectStorageRules(options.projectDir, options.firebaseConfig);
   // Each declared instance's rules in force, null while its file is missing.
@@ -426,6 +430,7 @@ export async function createSandboxSession(
     const namespace = createPyricNamespace({
       boundHost: options.boundHost,
       allowedHosts: options.allowedHosts,
+      appPorts: options.appPorts,
       indexes: createIndexConfigStore(options.projectDir),
       thresholds: createThresholdConfigStore(options.projectDir),
       rateCaptures: createRateCaptureStore(options.projectDir),
@@ -457,9 +462,11 @@ export async function createSandboxSession(
     // Module files the latest failed reload asked for. Watched with the
     // last-good module files so fixing or creating one reloads.
     let attemptedModuleFiles: readonly string[] = [];
-    const firestoreSourcePath = firestoreRulesPath(options.projectDir, options.firebaseConfig);
+    const firestoreSourcePath = firestoreRulesPath(options.projectDir, options.firebaseConfig, options.project);
     const reloadFirestoreRules = async (): Promise<RulesReloadResult> => {
       const sourcePath = firestoreSourcePath;
+      // An array firebase.json that deploys no rules to (default) has no file to reload.
+      if (sourcePath === null) return { kind: 'not-configured' };
       const isSourceMissing = !existsSync(sourcePath);
       // A deleted source keeps the last-good rules. Without a rules file the
       // sandbox runs its default rules, which the SharedWorker sets to a
@@ -496,7 +503,8 @@ export async function createSandboxSession(
       }
     };
     const firestoreRulesFiles = (): readonly string[] => {
-      return [...new Set([firestoreSourcePath, ...firestore.moduleFiles, ...attemptedModuleFiles])];
+      const sourceFiles = firestoreSourcePath === null ? [] : [firestoreSourcePath];
+      return [...new Set([...sourceFiles, ...firestore.moduleFiles, ...attemptedModuleFiles])];
     };
     const databaseRulesFiles = (): readonly string[] => [...new Set([...database.targets, ...database.pending].map((target) => target.path))];
     // The Node host holds one store per instance, so each instance's rules

package/src/serve/server.ts

@@ -137,21 +137,43 @@ export function isAllowedOrigin(
   return originPort === expectedPort;
 }
 
+/**
+ * The Origin check once the app's ports are known: the Origin must name one of
+ * them. Both a page this app serves and a page on another local port are
+ * loopback, so only the port tells them apart. `undefined` means the ports
+ * are not known, and only the Origin's hostname is compared.
+ */
+function isAllowedOriginOnPorts(
+  originHeader: string | undefined,
+  boundHost: string,
+  extra: string[],
+  appPorts: readonly number[] | undefined,
+): boolean {
+  const portsUnknown = appPorts === undefined;
+  if (portsUnknown) return isAllowedOrigin(originHeader, boundHost, extra);
+  return appPorts.some((port) => isAllowedOrigin(originHeader, boundHost, extra, port));
+}
+
 /**
  * The combined guard for a WS `upgrade` request: BOTH the `Host` header
  * (DNS-rebinding) AND the `Origin` header (cross-origin hijack) must pass.
  * `upgrade` is a separate listener from the HTTP `request` event, so the
  * static server's request-time `isAllowedHost` never runs on it — every
  * upgrade mount point must call this before `wss.handleUpgrade`.
+ *
+ * Pass `appPorts` (the socket's `localPort`, plus any port `createAppPorts`
+ * learned) so a page on another local port is refused; without it only the
+ * Origin's hostname is compared.
  */
 export function isAllowedUpgrade(
   headers: { host?: string; origin?: string },
   boundHost: string,
   extra: string[] = [],
+  appPorts?: readonly number[],
 ): boolean {
   return (
     isAllowedHost(headers.host, boundHost, extra) &&
-    isAllowedOrigin(headers.origin, boundHost, extra)
+    isAllowedOriginOnPorts(headers.origin, boundHost, extra, appPorts)
   );
 }
 
@@ -208,17 +230,22 @@ export function isAllowedSessionToken(
 /**
  * Validates that an incoming HTTP request complies with both loopback Host
  * (DNS-rebinding) and Origin (cross-origin hijacking) restrictions.
+ *
+ * Pass `appPorts` (the socket's `localPort`, plus any port `createAppPorts`
+ * learned) so a page on another local port is refused; without it only the
+ * Origin's hostname is compared.
  */
 export function isAllowedLoopbackRequest(
   req: { headers?: IncomingHttpHeaders | Record<string, string | string[] | undefined> | Headers },
   boundHost: string,
   extra: string[] = [],
+  appPorts?: readonly number[],
 ): boolean {
   const hostHeader = getHeader(req, 'host');
   const originHeader = getHeader(req, 'origin');
   return (
     isAllowedHost(hostHeader, boundHost, extra) &&
-    isAllowedOrigin(originHeader, boundHost, extra)
+    isAllowedOriginOnPorts(originHeader, boundHost, extra, appPorts)
   );
 }
 

package/src/serve/vite-ai-config.ts

@@ -50,7 +50,6 @@ export function loadViteAiEnv(
     const isAuthKey =
       key === 'GEMINI_API_KEY' ||
       key === 'GOOGLE_GENAI_API_KEY' ||
-      key === 'VITE_GEMINI_API_KEY' ||
       key === 'PYRIC_API_KEY';
     if (isAuthKey && process.env[key] === undefined) {
       process.env[key] = val;
@@ -59,6 +58,25 @@ export function loadViteAiEnv(
   return loaded;
 }
 
+/** The Gemini key name Vite would serve to the browser. */
+const BROWSER_SERVED_GEMINI_KEY = 'VITE_GEMINI_API_KEY';
+
+/**
+ * Refuse a dev server whose environment or `.env` holds a Gemini key in
+ * `VITE_GEMINI_API_KEY`. Vite serves every `VITE_`-prefixed variable to the
+ * browser, so the key would reach every page the dev server serves (#1632).
+ * `env` is what `loadViteAiEnv` returned, which includes the shell's
+ * environment. A blank value holds no key and is left alone.
+ */
+export function refuseBrowserServedGeminiKey(env: Record<string, string | undefined>): void {
+  const value = env[BROWSER_SERVED_GEMINI_KEY];
+  const holdsKey = value !== undefined && value.trim() !== '';
+  if (!holdsKey) return;
+  throw new Error(
+    `@pyric/cli/vite: ${BROWSER_SERVED_GEMINI_KEY} is set. Vite serves every variable whose name starts with VITE_ to the browser, so this key would reach every page the dev server serves. Rename it to GEMINI_API_KEY in your environment or .env file. Pyric's dev server reads GEMINI_API_KEY and keeps it on the server.`,
+  );
+}
+
 /** Convert a public declarative engine into the JSON-safe worker wire shape. */
 export function engineConfigToWire(engine: PyricAiEngineConfig): AiEngineConfigWire {
   const isOpenAiEngine = engine.kind === 'openai';

package/src/serve/vite-functions-development.ts

@@ -1,19 +1,19 @@
 import type { Server } from 'node:http';
 import path from 'node:path';
 import type { ViteDevServer } from 'vite';
-import type { FunctionsRtdbProject } from '../functions-rtdb/project.js';
+import type { FunctionsProject } from '../functions/project.js';
 import {
   createFunctionsDevelopmentRuntime,
   createInProcessFunctionsPeerReadiness,
   type FunctionsDevelopmentEvent,
   type FunctionsDevelopmentResult,
   type FunctionsDevelopmentRuntime,
-} from '../functions-rtdb/development-runtime.js';
+} from '../functions/development-runtime.js';
 import type { BridgeMount } from './bridge-mount.js';
 
 export interface ViteFunctionsDevelopmentOptions {
   cwd: string;
-  project: FunctionsRtdbProject;
+  project: FunctionsProject;
   projectId: string;
   instance?: string;
   region?: string;

package/src/serve/vite-generation-bridge.ts

@@ -1,6 +1,6 @@
 import type { Server as HttpServer } from 'node:http';
 import type { ViteDevServer } from 'vite';
-import type { FunctionsRtdbProject } from '../functions-rtdb/project.js';
+import type { FunctionsProject } from '../functions/project.js';
 import type {
   BridgeHostAttachment,
   BridgeHostOptions,
@@ -19,7 +19,7 @@ export function createViteGenerationBridge(input: {
   projectDir: string;
   hosted?: boolean;
   options: Omit<BridgeMountOptions, 'upgradeGuard'> | null;
-  functionsProject: FunctionsRtdbProject | null;
+  functionsProject: FunctionsProject | null;
   functionsProjectId: string | null;
   createBridge(options: BridgeMountOptions): BridgeMount;
 }): BridgeMount | null {

package/src/serve/vite-generation-functions.ts

@@ -4,8 +4,8 @@ import path from 'node:path';
 import type { ViteDevServer } from 'vite';
 import type { FirebaseProjectResolution } from '../cli/firebase-project.js';
 import type {
-  FunctionsRtdbProject,
-} from '../functions-rtdb/project.js';
+  FunctionsProject,
+} from '../functions/project.js';
 import type { BridgeMount } from './bridge-mount.js';
 import type {
   ViteFunctionsDevelopmentAttachment,
@@ -14,7 +14,7 @@ import type {
 
 export interface ResolvedViteGenerationFunctions {
   options: { region?: string; instance?: string; watch?: boolean };
-  project: FunctionsRtdbProject | null;
+  project: FunctionsProject | null;
   projectId: string | null;
 }
 
@@ -25,7 +25,7 @@ export interface ResolvedViteGenerationFunctions {
 export function resolveViteGenerationFunctions(input: {
   projectDir: string;
   options: false | { region?: string; instance?: string; watch?: boolean };
-  discover(projectDir: string): FunctionsRtdbProject | null;
+  discover(projectDir: string): FunctionsProject | null;
   firebaseProject: FirebaseProjectResolution;
 }): ResolvedViteGenerationFunctions {
   const { projectDir, options, discover, firebaseProject } = input;
@@ -49,7 +49,7 @@ export function attachViteGenerationFunctions(input: {
 }): ViteFunctionsDevelopmentAttachment | null {
   const { server, projectDir, cliRoot, bridge, resolved, registerModuleUrl, attach } = input;
   if (!resolved.project || !resolved.projectId || !bridge || !server.httpServer) return null;
-  const builtChild = path.join(cliRoot, 'dist/functions-rtdb/child.js');
+  const builtChild = path.join(cliRoot, 'dist/functions/child.js');
   const fileExists = input.fileExists ?? existsSync;
   const childModuleUrl = fileExists(builtChild) ? builtChild : undefined;
   const host =

package/src/serve/vite-generation-middleware.ts

@@ -1,9 +1,28 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { ViteDevServer } from 'vite';
-import type { BridgeMount } from './bridge-mount.js';
+import { answerMountClosed, HEALTH_PATH, type BridgeMount } from './bridge-mount.js';
 import type { SandboxSession } from './sandbox-session.js';
 import { isAllowedHost } from './server.js';
 
+/** The request's path, from the URL before Connect stripped the `/__pyric` mount. */
+function requestPath(req: IncomingMessage & { originalUrl?: string }): string {
+  const raw = req.originalUrl ?? req.url ?? '/';
+  const queryAt = raw.indexOf('?');
+  return queryAt === -1 ? raw : raw.slice(0, queryAt);
+}
+
+/**
+ * Live generations per Connect stack. A restarted Vite server gets a new
+ * stack, so the old server's stack has none while its replacement starts. A
+ * plugin configured twice on one server stacks both generations, and the
+ * live one answers.
+ */
+const liveGenerations = new WeakMap<object, number>();
+
+function adjustLive(stack: object, by: number): void {
+  liveGenerations.set(stack, (liveGenerations.get(stack) ?? 0) + by);
+}
+
 /** Attach one generation's guarded namespace handler to Vite's permanent Connect stack. */
 export function attachViteGenerationMiddleware(input: {
   server: ViteDevServer;
@@ -12,12 +31,25 @@ export function attachViteGenerationMiddleware(input: {
 }): () => void {
   const { server, bridge, session } = input;
   const serverOptions = server.config.server;
+  const stack = server.middlewares;
   let active = true;
+  adjustLive(stack, 1);
 
   server.middlewares.use(
     '/__pyric',
     (req: IncomingMessage & { originalUrl?: string }, res: ServerResponse, next: () => void) => {
       if (!active) {
+        // With no live generation on this stack, a closed generation's mount
+        // still says it is closing, as the mount itself does once closed, so
+        // `pyric run --wait` waits for the restarted server instead of
+        // reading Vite's 404 as "not a host" (#1568).
+        const isHealthRequest = requestPath(req) === HEALTH_PATH;
+        const hasLiveGeneration = (liveGenerations.get(stack) ?? 0) > 0;
+        const answersClosing = bridge !== null && isHealthRequest && !hasLiveGeneration;
+        if (answersClosing) {
+          answerMountClosed(res);
+          return;
+        }
         next();
         return;
       }
@@ -52,5 +84,9 @@ export function attachViteGenerationMiddleware(input: {
     },
   );
 
-  return () => { active = false; };
+  return () => {
+    if (!active) return;
+    active = false;
+    adjustLive(stack, -1);
+  };
 }

package/src/serve/vite-module-swap.ts

@@ -20,6 +20,8 @@ import { loadServerTarget } from './vite-ssr-loader.js';
 
 const FIREBASE_SPECIFIER = /^firebase\/([a-z-]+(?:\/[a-z-]+)*)$/;
 const NODE_SHIM_PREFIX = '\0pyric:node-shim:';
+/** The SDK package the served entries import; one instance per page. */
+const PYRIC_PACKAGE = 'pyric';
 type OptimizerOptions = NonNullable<DepOptimizationOptions['esbuildOptions']>;
 type OptimizerPlugin = NonNullable<OptimizerOptions['plugins']>[number];
 
@@ -244,6 +246,12 @@ export function createViteModuleSwap(
         '@firebase/app-check',
         '@firebase/util',
         '@firebase/logger',
+        // A page's own `pyric/*` import would otherwise get a pre-bundled copy
+        // of pyric, with its own app registry, and the served entries would
+        // resolve to that copy too. The page and the entries must share the
+        // one pyric `initializeApp` registers apps in (#1506). The bare name
+        // covers every subpath.
+        PYRIC_PACKAGE,
       ];
       const usesRolldown = Number(viteVersion.split('.')[0]) >= 8;
       const optimizer = usesRolldown

package/src/serve/vite-page-runtime.ts

@@ -3,6 +3,7 @@ import type { ConfigEnv, UserConfig } from 'vite';
 import { SANDBOX_BUILD_META } from './sandbox-marker.js';
 import {
   loadViteAiEnv,
+  refuseBrowserServedGeminiKey,
   resolveViteAiConfig,
   type PyricAiOptions,
   type ResolvedViteAiConfig,
@@ -72,6 +73,11 @@ export function createVitePageRuntime(input: {
     config(config, env) {
       sandboxBuild = env.command === 'build';
       const loadedEnv = loadViteAiEnv(env.mode, config.root, config.envDir);
+      // Only the dev server serves `import.meta.env` to pages. A build's
+      // output and `vite preview`, which serves it, never held the key. The
+      // same condition as `isDevServer` in `vite-plugin.ts`.
+      const isDevServer = env.command === 'serve' && env.isPreview !== true;
+      if (isDevServer) refuseBrowserServedGeminiKey(loadedEnv);
       resolvedAi = resolveViteAiConfig(options.ai, loadedEnv);
       // The Vite dev server is the process `pyric sandbox` guards, and it
       // dials these destinations itself, so its guard must permit them.

package/src/serve/vite-rules-source.ts

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
-import type { FirebaseJson } from '../cli/firebase-json.js';
+import { withDefaultFirestoreRules, type FirebaseJson } from '../cli/firebase-json.js';
 
 /**
  * Apply the Vite authoring convention without replacing unrelated Firebase
@@ -25,10 +25,7 @@ export function resolveViteRulesConfig(
     ...(firebaseConfig ?? {}),
   };
   if (firestoreSource) {
-    resolved.firestore = {
-      ...(firebaseConfig?.firestore ?? {}),
-      rules: firestoreSource,
-    };
+    resolved.firestore = withDefaultFirestoreRules(firebaseConfig?.firestore, firestoreSource);
   }
   if (storageSource) {
     const storage = firebaseConfig?.storage;

package/src/serve/vite-sandbox-generation.ts

@@ -5,9 +5,9 @@ import { readFirebaseJson, readFirebaseRc, type FirebaseJson } from '../cli/fire
 import { resolveFirebaseProject } from '../cli/firebase-project.js';
 import { registerModuleUrl } from '../cli/sandbox-runner.js';
 import {
-  discoverFunctionsRtdbProject,
-  type FunctionsRtdbProject,
-} from '../functions-rtdb/project.js';
+  discoverFunctionsProject,
+  type FunctionsProject,
+} from '../functions/project.js';
 import { formatActivityWarning } from './activity-warning.js';
 import { formatAiStatusNote } from './ai-status.js';
 import {
@@ -101,7 +101,7 @@ export interface ViteSandboxGenerationDependencies {
   resolveAvatarsConfig: typeof resolveAvatarsConfig;
   prepareWorker(runtime: ViteWorkerRuntime, epochSalt: string): Promise<void>;
   workerStatus(runtime: ViteWorkerRuntime): ViteWorkerRuntimeStatus;
-  discoverFunctionsProject(cwd: string): FunctionsRtdbProject | null;
+  discoverFunctionsProject(cwd: string): FunctionsProject | null;
   resolveSiteUiDir: typeof resolveSiteUiDir;
   createBridge(options: BridgeMountOptions): BridgeMount;
   createSession(options: SandboxSessionOptions): Promise<SandboxSession>;
@@ -118,7 +118,7 @@ const DEFAULT_DEPENDENCIES: ViteSandboxGenerationDependencies = {
   resolveAvatarsConfig,
   prepareWorker: (runtime, epochSalt) => runtime.prepare(epochSalt),
   workerStatus: (runtime) => runtime.status(),
-  discoverFunctionsProject: discoverFunctionsRtdbProject,
+  discoverFunctionsProject: discoverFunctionsProject,
   resolveSiteUiDir,
   createBridge: createBridgeMount,
   createSession: createSandboxSession,