@pyric/cli 0.1.0-alpha.16 → 0.1.0-alpha.18

package/src/serve/runtime/chip-config.ts

@@ -17,14 +17,27 @@ interface RuntimeChipDocument {
   querySelector(selector: string): { getAttribute(name: string): string | null } | null;
 }
 
-/** Read only plugin-authored values; absent/unknown metadata keeps the UI off. */
+function hasBundlerRuntimeChipConfig(): boolean {
+  return typeof process !== 'undefined' && typeof process.env !== 'undefined' && typeof process.env.PYRIC_RUNTIME_CHIP === 'string';
+}
+
+/** Read plugin-authored values from DOM metadata or bundler environment variables, defaulting to collapsed UI when omitted. */
 export function readPyricRuntimeChipConfig(
   documentLike: RuntimeChipDocument,
 ): PyricRuntimeChipConfig | null {
   const meta = documentLike.querySelector(`meta[name="${PYRIC_RUNTIME_CHIP_META}"]`);
-  const value = meta?.getAttribute('content');
-  const studioEnabled = meta?.getAttribute('data-studio') !== 'off';
-  if (value === 'collapsed') return { initiallyOpen: false, studioEnabled };
-  if (value === 'expanded') return { initiallyOpen: true, studioEnabled };
-  return null;
+  const hasMetaTag = meta !== null;
+  let value = hasMetaTag ? meta.getAttribute('content') : null;
+
+  const shouldFallbackToEnv = !hasMetaTag && hasBundlerRuntimeChipConfig();
+  if (shouldFallbackToEnv) {
+    value = process.env.PYRIC_RUNTIME_CHIP as string;
+  }
+  if (value === 'off') {
+    return null;
+  }
+
+  const studioEnabled = !hasMetaTag || meta.getAttribute('data-studio') !== 'off';
+  const initiallyOpen = value === 'expanded';
+  return { initiallyOpen, studioEnabled };
 }

package/src/serve/runtime/chip.ts

@@ -94,9 +94,12 @@ const styles = `
   .errors { background: var(--pyric-content); border-bottom: 1px solid var(--pyric-border-soft); border-top: 1px solid var(--pyric-border-soft); max-height: 184px; min-height: 58px; overflow-y: auto; }
   .errors::-webkit-scrollbar { width: 8px; }
   .errors::-webkit-scrollbar-thumb { background: #33333f; border-radius: 4px; }
-  .error-row { align-items: flex-start; border-bottom: 1px solid rgba(42,42,53,.7); display: grid; gap: 8px; grid-template-columns: 18px minmax(0,1fr) 28px; padding: 10px 8px 10px 12px; }
+  .error-row { align-items: flex-start; border-bottom: 1px solid rgba(42,42,53,.7); display: grid; gap: 8px; grid-template-columns: 18px minmax(0,1fr) 28px 28px; padding: 10px 8px 10px 12px; }
   .error-row:last-child { border-bottom: 0; }
   .error-number { color: var(--pyric-error); font: 10px/20px ui-monospace, monospace; }
+  .panel-controls { align-items: center; display: inline-flex; gap: 4px; }
+  .clear-button { background: transparent; border: 0; color: var(--pyric-muted); cursor: pointer; font-size: 11px; margin-left: 8px; padding: 2px 6px; }
+  .clear-button:hover { color: var(--pyric-text); }
   .error-body { min-width: 0; }
   .error-body code { color: #d7d7df; display: block; font-size: 11px; line-height: 1.55; overflow-wrap: anywhere; white-space: pre-wrap; }
   .error-meta { color: var(--pyric-muted); font: 9px/1.4 ui-monospace, monospace; margin-top: 4px; overflow-wrap: anywhere; }
@@ -122,6 +125,7 @@ const styles = `
 
 const icons = {
   close: '<svg class="icon" aria-hidden="true" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8"><path d="m6 6 12 12M18 6 6 18"/></svg>',
+  minimize: '<svg class="icon" aria-hidden="true" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8"><path d="M5 12h14"/></svg>',
   copy: '<svg class="icon" aria-hidden="true" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8"><rect x="8" y="8" width="11" height="11" rx="1"/><path d="M16 8V5H5v11h3"/></svg>',
   chevron: '<svg class="chevron" aria-hidden="true" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8"><path d="m6 15 6-6 6 6"/></svg>',
   external: '<svg aria-hidden="true" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8"><path d="M14 5h5v5M19 5l-8 8"/><path d="M19 13v6H5V5h6"/></svg>',
@@ -148,6 +152,7 @@ function renderErrors(snapshot: PyricRuntimeSnapshot, canCopy: boolean): string
       <span class="error-number">${String(index + 1).padStart(2, '0')}</span>
       <div class="error-body"><code></code><div class="error-meta"></div></div>
       <button class="icon-button" type="button" data-copy-error="${escapeAttribute(error.id)}" aria-label="${canCopy ? `Copy error ${index + 1}` : 'Copy unavailable'}" title="${canCopy ? 'Copy error' : 'Clipboard unavailable'}" ${canCopy ? '' : 'disabled'}>${icons.copy}</button>
+      <button class="icon-button" type="button" data-dismiss-error="${escapeAttribute(error.id)}" aria-label="Dismiss error ${index + 1}" title="Dismiss error">${icons.close}</button>
     </div>
   `).join('');
 }
@@ -202,8 +207,11 @@ export function mountPyricRuntimeChip(options: PyricRuntimeChipOptions): PyricRu
     view.innerHTML = `${open ? `
       <section class="panel" role="dialog" aria-label="Pyric runtime">
         <header class="panel-header">
-          <div class="panel-title"><span class="brand-mark">&gt;_</span><strong>Pyric runtime</strong>${errorCount > 0 ? `<span class="count">${errorCount} ${errorCount === 1 ? 'error' : 'errors'}</span>` : ''}</div>
-          <button class="icon-button" type="button" data-collapse aria-label="Collapse Pyric runtime">${icons.close}</button>
+          <div class="panel-title"><span class="brand-mark">&gt;_</span><strong>Pyric runtime</strong>${errorCount > 0 ? `<span class="count">${errorCount} ${errorCount === 1 ? 'error' : 'errors'}</span><button class="clear-button" type="button" data-clear-errors aria-label="Clear all errors">Clear</button>` : ''}</div>
+          <div class="panel-controls">
+            <button class="icon-button" type="button" data-collapse aria-label="Minimize Pyric runtime">${icons.minimize}</button>
+            <button class="icon-button" type="button" data-dismiss-chip aria-label="Dismiss Pyric runtime from page">${icons.close}</button>
+          </div>
         </header>
         <div class="worker-state"><span class="state-label${snapshot.updateAvailable ? ' available' : ''}"><span class="mini-dot"></span>${workerLabel}</span><span class="epochs">${epochs}</span></div>
         <div class="errors" data-error-viewport>${renderErrors(snapshot, Boolean(clipboard))}</div>
@@ -247,6 +255,12 @@ export function mountPyricRuntimeChip(options: PyricRuntimeChipOptions): PyricRu
       render();
       root.querySelector<HTMLButtonElement>('[data-expand]')?.focus();
     });
+    root.querySelector('[data-clear-errors]')?.addEventListener('click', () => {
+      options.runtime.clearErrors();
+    });
+    root.querySelector('[data-dismiss-chip]')?.addEventListener('click', () => {
+      host.style.display = 'none';
+    });
     root.querySelector('[data-update-worker]')?.addEventListener('click', () => {
       if (!snapshot.updateAvailable || snapshot.updatingWorker) return;
       void options.runtime.updateWorker().catch(() => { /* status records and renders the failure */ });
@@ -262,6 +276,13 @@ export function mountPyricRuntimeChip(options: PyricRuntimeChipOptions): PyricRu
         });
       });
     }
+    for (const button of root.querySelectorAll<HTMLButtonElement>('[data-dismiss-error]')) {
+      button.addEventListener('click', () => {
+        if (button.dataset.dismissError) {
+          options.runtime.dismissError(button.dataset.dismissError);
+        }
+      });
+    }
     if (focusToken) {
       const candidates = root.querySelectorAll<HTMLElement>(`[${focusToken.attribute}]`);
       const replacement = [...candidates].find((candidate) =>

package/src/serve/runtime/status.ts

@@ -36,6 +36,7 @@ export interface PyricRuntimeStatus {
   reportError(error: unknown, source: PyricRuntimeErrorSource): void;
   recordSandboxEvents(events: readonly SandboxEvent[]): void;
   clearErrors(): void;
+  dismissError(id: string): void;
 }
 
 let nextErrorId = 0;
@@ -77,41 +78,95 @@ export function normalizePyricRuntimeError(
   return { id, source, at, message: String(value) };
 }
 
+function isOperationOrRequestEvent(event: SandboxEvent): boolean {
+  const isOperationKind = event.kind === 'operation';
+  const isRequestKind = event.kind === 'request';
+  return isOperationKind || isRequestKind;
+}
+
+function isDeniedOperationEvent(event: SandboxEvent): boolean {
+  const isTargetEventKind = isOperationOrRequestEvent(event);
+  const hasResultProperty = 'result' in event;
+  const isDeniedResult = hasResultProperty && event.result === 'deny';
+  return isTargetEventKind && isDeniedResult;
+}
+
+function isRuntimeErrorEvent(event: SandboxEvent): boolean {
+  return event.kind === 'runtime_error';
+}
+
+function isListenerErroredEvent(event: SandboxEvent): boolean {
+  const isListenerErroredKind = event.kind === 'listener_errored';
+  const hasErrorPayload = 'error' in event && Boolean(event.error);
+  return isListenerErroredKind && hasErrorPayload;
+}
+
+function isListenerPhaseErroredEvent(event: SandboxEvent): boolean {
+  const isListenerKind = event.kind === 'listener';
+  const isErroredPhase = 'phase' in event && event.phase === 'errored';
+  const hasErrorPayload = 'error' in event && Boolean(event.error);
+  return isListenerKind && isErroredPhase && hasErrorPayload;
+}
+
 function sandboxError(event: SandboxEvent): PyricRuntimeError | null {
-  if (event.kind === 'runtime_error') {
+  if (isRuntimeErrorEvent(event)) {
+    const hasPathProperty = 'path' in event && typeof event.path === 'string';
+    const targetPath = hasPathProperty ? event.path : undefined;
+    const hasMethodProperty = 'method' in event && typeof event.method === 'string';
+    const targetMethod = hasMethodProperty ? event.method : 'unknown';
+    const hasErrorPayload = 'error' in event && Boolean(event.error);
+    const errorPayload = hasErrorPayload ? (event as { error: { code?: string; message: string } }).error : undefined;
     return {
       id: event.id,
       source: 'sandbox',
       at: event.at,
       service: event.service,
-      method: event.method,
-      ...(event.path ? { path: event.path } : {}),
-      ...(event.error.code ? { code: event.error.code } : {}),
-      message: event.error.message,
+      method: targetMethod,
+      ...(targetPath ? { path: targetPath } : {}),
+      ...(errorPayload?.code ? { code: errorPayload.code } : {}),
+      message: errorPayload?.message ? errorPayload.message : 'Sandbox runtime error',
     };
   }
-  if (event.kind === 'listener_errored' && event.error) {
+  if (isListenerErroredEvent(event)) {
+    const errorPayload = (event as { error: { code?: string; message: string } }).error;
     return {
       id: event.id,
       source: 'sandbox',
       at: event.at,
       service: 'firestore',
       method: 'listener',
-      ...('path' in event.target ? { path: event.target.path } : {}),
-      code: event.error.code,
-      message: event.error.message,
+      ...('target' in event && event.target && 'path' in event.target ? { path: event.target.path } : {}),
+      code: errorPayload.code,
+      message: errorPayload.message,
     };
   }
-  if (event.kind === 'listener' && event.phase === 'errored' && event.error) {
+  if (isListenerPhaseErroredEvent(event)) {
+    const errorPayload = (event as { error: { code?: string; message: string } }).error;
     return {
       id: event.id,
       source: 'sandbox',
       at: event.at,
       service: event.service,
       method: 'listener',
-      ...(event.target.path ? { path: event.target.path } : {}),
-      ...(event.error.code ? { code: event.error.code } : {}),
-      message: event.error.message,
+      ...('target' in event && event.target && 'path' in event.target ? { path: event.target.path } : {}),
+      ...(errorPayload.code ? { code: errorPayload.code } : {}),
+      message: errorPayload.message,
+    };
+  }
+  if (isDeniedOperationEvent(event)) {
+    const hasPathProperty = 'path' in event && typeof event.path === 'string';
+    const targetPath = hasPathProperty ? event.path : '(service)';
+    const hasMethodProperty = 'method' in event && typeof event.method === 'string';
+    const targetMethod = hasMethodProperty ? event.method : 'operation';
+    return {
+      id: event.id,
+      source: 'sandbox',
+      at: event.at,
+      service: event.service,
+      method: targetMethod,
+      path: targetPath,
+      code: 'PERMISSION_DENIED',
+      message: `PERMISSION_DENIED: ${targetMethod} on ${targetPath} denied by rules`,
     };
   }
   return null;
@@ -201,6 +256,14 @@ export function createPyricRuntimeStatus(
       errorIds.clear();
       publish({ ...snapshot, errors: [] });
     },
+    dismissError(id) {
+      if (!errorIds.has(id)) return;
+      errorIds.delete(id);
+      publish({
+        ...snapshot,
+        errors: snapshot.errors.filter((err) => err.id !== id),
+      });
+    },
   };
 }
 

package/src/serve/sandbox-session.ts

@@ -63,6 +63,7 @@ export interface SandboxSession {
   payload(): InitPayload;
   handle(req: IncomingMessage, res: ServerResponse, url: URL): boolean | Promise<boolean>;
   reloadFirestoreRules(): Promise<RulesReloadResult>;
+  reloadDatabaseRules(): Promise<RulesReloadResult>;
   close(): Promise<void>;
 }
 
@@ -93,6 +94,8 @@ export async function createSandboxSession(
   const live = {
     rules: firestore.rules,
     rulesHash: firestore.rulesHash,
+    databaseRules: database.rules,
+    databaseRulesHash: database.rulesHash,
   };
   const events = createEventHub();
   const capture: CaptureStore | undefined = (options.capture ?? true)
@@ -145,8 +148,8 @@ export async function createSandboxSession(
   const payload = (): InitPayload => ({
     rules: live.rules,
     rulesHash: live.rulesHash,
-    databaseRules: database.rules,
-    databaseRulesHash: database.rulesHash,
+    databaseRules: live.databaseRules,
+    databaseRulesHash: live.databaseRulesHash,
     databaseUrl: database.databaseUrl,
     storageRules: storage.rules,
     storageRulesHash: storage.rulesHash,
@@ -217,6 +220,31 @@ export async function createSandboxSession(
       return { kind: 'rejected', error: error instanceof Error ? error : new Error(String(error)) };
     }
   };
+  const reloadDatabaseRules = async (): Promise<RulesReloadResult> => {
+    const isMissingDatabaseRules = database.sourcePath === null;
+    if (isMissingDatabaseRules) {
+      return { kind: 'not-configured' };
+    }
+    try {
+      const updated = await loadProjectDatabaseRules(options.projectDir, options.firebaseConfig);
+      const isMissingUpdatedRules = updated.rules === null || updated.rulesHash === null;
+      if (isMissingUpdatedRules) {
+        return { kind: 'not-configured' };
+      }
+      live.databaseRules = updated.rules;
+      live.databaseRulesHash = updated.rulesHash;
+      events.broadcast('rtdb-rules-update', { rules: updated.rules, rulesHash: updated.rulesHash });
+      return { kind: 'reloaded', rulesHash: updated.rulesHash as string, clients: events.clientCount() };
+    } catch (error) {
+      const isErrorInstance = error instanceof Error;
+      let errorResult: Error = new Error(String(error));
+      if (isErrorInstance) {
+        errorResult = error as Error;
+      }
+      return { kind: 'rejected', error: errorResult };
+    }
+  };
+
   let closePromise: Promise<void> | null = null;
   const close = (): Promise<void> => {
     closePromise ??= Promise.resolve().then(() => events.close());
@@ -228,6 +256,7 @@ export async function createSandboxSession(
     payload,
     handle: namespace,
     reloadFirestoreRules,
+    reloadDatabaseRules,
     close,
   };
 }

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

@@ -9,6 +9,8 @@ const AI_PROXY_PATH = '/__pyric/ai-proxy';
 export type PyricAiEngineConfig = Extract<NonNullable<AIOptions['engine']>, { kind: string }>;
 
 export interface PyricAiOptions {
+  /** Mode for AI Logic: 'sandbox' (local mirrors) or 'production' (pass-through to Google AI / Vertex AI). */
+  mode?: 'sandbox' | 'production';
   /** Simple OpenAI-compatible model selection through Pyric's same-origin proxy. */
   model?: string;
   /** Advanced declarative engine configuration. */
@@ -18,6 +20,7 @@ export interface PyricAiOptions {
 }
 
 export interface ResolvedViteAiConfig {
+  mode: 'sandbox' | 'production';
   engineWire: AiEngineConfigWire | undefined;
   proxyUpstream: string | undefined;
 }
@@ -26,8 +29,9 @@ export interface ResolvedViteAiConfig {
 export function viteWorkerEpochSalt(
   projectKey: string,
   engineWire: AiEngineConfigWire | undefined,
+  mode: 'sandbox' | 'production' = 'sandbox',
 ): string {
-  return JSON.stringify({ projectKey, aiEngine: engineWire ?? null });
+  return JSON.stringify({ projectKey, aiEngine: engineWire ?? null, aiMode: mode });
 }
 
 /** Load env using Vite's `envDir`-relative-to-root convention. */
@@ -45,20 +49,30 @@ export function loadViteAiEnv(
 
 /** Convert a public declarative engine into the JSON-safe worker wire shape. */
 export function engineConfigToWire(engine: PyricAiEngineConfig): AiEngineConfigWire {
-  if (engine.kind === 'openai') {
-    return {
+  const isOpenAiEngine = engine.kind === 'openai';
+  if (isOpenAiEngine) {
+    const result: Record<string, unknown> = {
       kind: 'openai',
-      baseUrl: engine.baseUrl ?? AI_PROXY_PATH,
-      ...(engine.model !== undefined ? { model: engine.model } : {}),
-      ...(engine.modelMap !== undefined ? { modelMap: engine.modelMap } : {}),
+      baseUrl: engine.baseUrl !== undefined && engine.baseUrl !== null ? engine.baseUrl : AI_PROXY_PATH,
     };
+    const hasModel = engine.model !== undefined;
+    if (hasModel) {
+      result.model = engine.model;
+    }
+    const hasModelMap = engine.modelMap !== undefined;
+    if (hasModelMap) {
+      result.modelMap = engine.modelMap;
+    }
+    return result as AiEngineConfigWire;
   }
-  return {
+  const result: Record<string, unknown> = {
     kind: 'scripted',
-    ...(engine.script !== undefined
-      ? { script: engine.script as unknown as Array<Record<string, unknown>> }
-      : {}),
   };
+  const hasScript = engine.script !== undefined;
+  if (hasScript) {
+    result.script = engine.script as unknown as Array<Record<string, unknown>>;
+  }
+  return result as AiEngineConfigWire;
 }
 
 /** Resolve the plugin's explicit-options-over-Vite-env AI convention. */
@@ -66,20 +80,73 @@ export function resolveViteAiConfig(
   options: PyricAiOptions | undefined,
   env: Record<string, string | undefined>,
 ): ResolvedViteAiConfig {
-  if (options?.model !== undefined && options.engine !== undefined) {
+  const explicitModel = options?.model;
+  const explicitEngine = options?.engine;
+  const hasModelOption = explicitModel !== undefined;
+  const hasEngineOption = explicitEngine !== undefined;
+  const hasBothModelAndEngine = hasModelOption && hasEngineOption;
+  if (hasBothModelAndEngine) {
     throw new Error('@pyric/cli/vite: Choose either ai.model or ai.engine, not both.');
   }
 
-  const model = options?.model?.trim() || env.PYRIC_AI_MODEL?.trim();
-  const engineWire = options?.engine
-    ? engineConfigToWire(options.engine)
-    : model
-      ? engineConfigToWire({ kind: 'openai', baseUrl: AI_PROXY_PATH, model })
-      : undefined;
+  let mode: 'sandbox' | 'production' = 'sandbox';
+  const explicitMode = options?.mode;
+  const hasExplicitMode = explicitMode !== undefined;
+  if (hasExplicitMode) {
+    mode = explicitMode;
+  } else {
+    const isEnvProductionMode = env.PYRIC_AI_MODE === 'production';
+    const isEnvPassthroughFlag = env.PYRIC_AI_PASSTHROUGH === '1';
+    const isProductionEnv = isEnvProductionMode || isEnvPassthroughFlag;
+    if (isProductionEnv) {
+      mode = 'production';
+    }
+  }
+
+  const isProductionMode = mode === 'production';
+  const hasAnyEngineConfig = hasModelOption || hasEngineOption;
+  const isInvalidProductionConfig = isProductionMode && hasAnyEngineConfig;
+  if (isInvalidProductionConfig) {
+    throw new Error('@pyric/cli/vite: Cannot configure ai.model or ai.engine when ai.mode is set to "production".');
+  }
+
+  let model: string | undefined = undefined;
+  const envModel = env.PYRIC_AI_MODEL;
+  if (explicitModel !== undefined) {
+    model = explicitModel.trim();
+  } else if (envModel !== undefined) {
+    model = envModel.trim();
+  }
+  const hasNonEmptyModel = model !== undefined && model !== '';
+  if (!hasNonEmptyModel) {
+    model = undefined;
+  }
+
+  let engineWire: AiEngineConfigWire | undefined = undefined;
+  if (!isProductionMode) {
+    if (explicitEngine !== undefined) {
+      engineWire = engineConfigToWire(explicitEngine);
+    } else if (model !== undefined) {
+      engineWire = engineConfigToWire({ kind: 'openai', baseUrl: AI_PROXY_PATH, model });
+    }
+  }
+
+  let proxyUpstream: string | undefined = undefined;
+  const explicitProxyUpstream = options?.proxyUpstream;
+  const envProxyUpstream = env.PYRIC_AI_PROXY_UPSTREAM;
+  if (explicitProxyUpstream !== undefined) {
+    proxyUpstream = explicitProxyUpstream.trim();
+  } else if (envProxyUpstream !== undefined) {
+    proxyUpstream = envProxyUpstream.trim();
+  }
+  const hasNonEmptyProxyUpstream = proxyUpstream !== undefined && proxyUpstream !== '';
+  if (!hasNonEmptyProxyUpstream) {
+    proxyUpstream = undefined;
+  }
 
   return {
+    mode,
     engineWire,
-    proxyUpstream:
-      options?.proxyUpstream?.trim() || env.PYRIC_AI_PROXY_UPSTREAM?.trim() || undefined,
+    proxyUpstream,
   };
 }

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

@@ -144,6 +144,7 @@ export function attachViteFunctionsDevelopment(
       registerUrl: options.registerUrl,
       instance: options.instance ?? `${options.projectId}-default-rtdb`,
       location: options.region ?? options.baseEnv.PYRIC_FUNCTIONS_RTDB_REGION ?? 'us-central1',
+      projectId: options.projectId,
       readiness: createInProcessFunctionsPeerReadiness(bridge.sandboxConnected),
       onEvent: (event) => reportEvent(options.logger, event),
       ...(options.childModuleUrl === undefined ? {} : { childModuleUrl: options.childModuleUrl }),

package/src/serve/vite-generation-rules-watch.ts

@@ -8,30 +8,82 @@ export function watchViteGenerationRules(input: {
   session: SandboxSession;
 }): (() => void) | null {
   const { server, session } = input;
-  const rulesFile = session.summary.rules.firestore.sourcePath;
-  if (!rulesFile) return null;
+  const firestoreFile = session.summary.rules.firestore.sourcePath;
+  const databaseFile = session.summary.rules.database.sourcePath;
+  const hasFirestoreFile = firestoreFile !== null;
+  const hasDatabaseFile = databaseFile !== null;
+  const hasNeitherFile = !hasFirestoreFile && !hasDatabaseFile;
+  if (hasNeitherFile) {
+    return null;
+  }
 
   let debounce: ReturnType<typeof setTimeout> | null = null;
   const onRulesChange = (file: string): void => {
-    if (path.resolve(file) !== path.resolve(rulesFile)) return;
-    if (debounce) clearTimeout(debounce);
+    const resolvedFile = path.resolve(file);
+    let isFirestoreMatch = false;
+    if (hasFirestoreFile) {
+      const firestoreResolved = path.resolve(firestoreFile);
+      isFirestoreMatch = resolvedFile === firestoreResolved;
+    }
+    let isDatabaseMatch = false;
+    if (hasDatabaseFile) {
+      const databaseResolved = path.resolve(databaseFile);
+      isDatabaseMatch = resolvedFile === databaseResolved;
+    }
+    const isNeitherMatch = !isFirestoreMatch && !isDatabaseMatch;
+    if (isNeitherMatch) {
+      return;
+    }
+    const hasDebounce = debounce !== null;
+    if (hasDebounce) {
+      clearTimeout(debounce as ReturnType<typeof setTimeout>);
+    }
     debounce = setTimeout(() => {
-      void session.reloadFirestoreRules().then((result) => {
-        if (result.kind === 'reloaded') {
-          server.config.logger.info(`  ↻ [pyric] rules reloaded (${result.rulesHash})`);
-        } else if (result.kind === 'rejected') {
-          server.config.logger.warn(
-            `  ⚠ [pyric] rules NOT reloaded (last-good stays live): ${result.error.message}`,
-          );
-        }
-      });
+      if (isFirestoreMatch) {
+        void session.reloadFirestoreRules().then((result) => {
+          const isReloaded = result.kind === 'reloaded';
+          if (isReloaded) {
+            server.config.logger.info(`  ↻ [pyric] rules reloaded (${result.rulesHash})`);
+          } else {
+            const isRejected = result.kind === 'rejected';
+            if (isRejected) {
+              server.config.logger.warn(
+                `  ⚠ [pyric] rules NOT reloaded (last-good stays live): ${result.error.message}`,
+              );
+            }
+          }
+        });
+      }
+      if (isDatabaseMatch) {
+        void session.reloadDatabaseRules().then((result) => {
+          const isReloaded = result.kind === 'reloaded';
+          if (isReloaded) {
+            server.config.logger.info(`  ↻ [pyric] rtdb rules reloaded (${result.rulesHash})`);
+          } else {
+            const isRejected = result.kind === 'rejected';
+            if (isRejected) {
+              server.config.logger.warn(
+                `  ⚠ [pyric] rtdb rules NOT reloaded (last-good stays live): ${result.error.message}`,
+              );
+            }
+          }
+        });
+      }
     }, 150);
   };
 
-  server.watcher.add(rulesFile);
+  if (hasFirestoreFile) {
+    server.watcher.add(firestoreFile);
+  }
+  if (hasDatabaseFile) {
+    server.watcher.add(databaseFile);
+  }
   server.watcher.on('change', onRulesChange);
   return () => {
-    if (debounce) clearTimeout(debounce);
+    const hasDebounce = debounce !== null;
+    if (hasDebounce) {
+      clearTimeout(debounce as ReturnType<typeof setTimeout>);
+    }
     server.watcher.off('change', onRulesChange);
   };
 }