@pyric/cli 0.1.0-alpha.15 → 0.1.0-alpha.17

package/src/next/client-aliases.ts

@@ -0,0 +1,39 @@
+/**
+ * Client-side module aliasing definitions for Firebase Web SDKs.
+ */
+import { defaultSdkEntries } from '../serve/bundler.js';
+
+/**
+ * Retrieve the explicit map of canonical Firebase import specifiers to their
+ * standalone Pyric browser wrapper entries.
+ */
+export function getClientAliases(): Record<string, string> {
+  const entries = defaultSdkEntries();
+  const aliases: Record<string, string> = {
+    'firebase/ai': entries.ai,
+    'firebase/app': entries.app,
+    'firebase/auth': entries.auth,
+    'firebase/firestore': entries.firestore,
+    'firebase/database': entries.database,
+    'firebase/messaging': entries.messaging,
+    'firebase/messaging/sw': entries['messaging-sw'],
+    'firebase/storage': entries.storage,
+  };
+  return aliases;
+}
+
+/**
+ * Retrieve benign boolean fallback replacements for Node built-in modules
+ * accessible in browser packaging bundles.
+ */
+export function getNodeBuiltinFallbacks(): Record<string, boolean> {
+  const fallbacks: Record<string, boolean> = {
+    fs: false,
+    path: false,
+    url: false,
+    'node:fs': false,
+    'node:path': false,
+    'node:url': false,
+  };
+  return fallbacks;
+}

package/src/next/dev-rewrites.ts

@@ -0,0 +1,77 @@
+/**
+ * Next.js dev-time rewrite rules for routing Pyric bridge and socket traffic.
+ */
+import type { NextConfigObject, PyricNextOptions } from './types.js';
+import { resolveSandboxTargetUrl } from './target-url.js';
+
+const PYRIC_PROXY_SOURCE = '/__pyric/:path*';
+const PYRIC_PROXY_PATH = '/__pyric/:path*';
+
+interface RewriteRule {
+  source: string;
+  destination: string;
+}
+
+interface RewritesObject {
+  beforeFiles?: RewriteRule[];
+  afterFiles?: RewriteRule[];
+  fallback?: RewriteRule[];
+  [key: string]: unknown;
+}
+
+function shouldSkipRewrites(options?: PyricNextOptions): boolean {
+  if (options === undefined) {
+    return false;
+  }
+  return options.rewrites === false;
+}
+
+function assembleRewriteRule(options?: PyricNextOptions): RewriteRule {
+  const targetUrl = resolveSandboxTargetUrl(options);
+  const destinationUrl = `${targetUrl}${PYRIC_PROXY_PATH}`;
+  const rule: RewriteRule = {
+    source: PYRIC_PROXY_SOURCE,
+    destination: destinationUrl,
+  };
+  return rule;
+}
+
+function prependToArrayRewrites(existing: RewriteRule[], pyricRule: RewriteRule): RewriteRule[] {
+  const combinedRules = [pyricRule, ...existing];
+  return combinedRules;
+}
+
+function prependToObjectRewrites(existing: RewritesObject, pyricRule: RewriteRule): RewritesObject {
+  const beforeFilesList = Array.isArray(existing.beforeFiles) ? existing.beforeFiles : [];
+  const updatedBeforeFiles = [pyricRule, ...beforeFilesList];
+  const updatedObject: RewritesObject = Object.assign({}, existing, { beforeFiles: updatedBeforeFiles });
+  return updatedObject;
+}
+
+/**
+ * Attach Pyric dev-time rewrites to ensure zero-CORS browser runtime communication.
+ */
+export function augmentDevRewrites(config: NextConfigObject, options?: PyricNextOptions): NextConfigObject {
+  if (shouldSkipRewrites(options)) {
+    return config;
+  }
+
+  const updatedConfig: NextConfigObject = Object.assign({}, config);
+  const pyricRule = assembleRewriteRule(options);
+  const originalRewrites = updatedConfig.rewrites;
+
+  updatedConfig.rewrites = async () => {
+    if (typeof originalRewrites === 'function') {
+      const existingRewrites = await originalRewrites();
+      if (Array.isArray(existingRewrites)) {
+        return prependToArrayRewrites(existingRewrites, pyricRule);
+      }
+      if (typeof existingRewrites === 'object' && existingRewrites !== null) {
+        return prependToObjectRewrites(existingRewrites as RewritesObject, pyricRule);
+      }
+    }
+    return [pyricRule];
+  };
+
+  return updatedConfig;
+}

package/src/next/guard.ts

@@ -0,0 +1,61 @@
+/**
+ * Execution policies and safety interlocks for Next.js configuration loading.
+ */
+import type { PyricNextOptions } from './types.js';
+
+const PRODUCTION_ENVIRONMENT = 'production';
+const FORCED_SANDBOX_FLAG = '1';
+
+/**
+ * Check whether the active environment requires production build passthrough
+ * without Pyric sandbox module substitution.
+ */
+export function isProductionPassthrough(): boolean {
+  const isProductionEnv = process.env.NODE_ENV === PRODUCTION_ENVIRONMENT;
+  const isForcedOverride = process.env.PYRIC_SANDBOX_FORCE === FORCED_SANDBOX_FLAG;
+  if (!isProductionEnv) {
+    return false;
+  }
+  return !isForcedOverride;
+}
+
+/**
+ * Check whether the developer opted out of the sandbox environment guard.
+ */
+function isGuardExplicitlyDisabled(options?: PyricNextOptions): boolean {
+  if (options === undefined) {
+    return false;
+  }
+  return options.guard === false;
+}
+
+/**
+ * Check whether an active Pyric sandbox environment variable is present in the process.
+ */
+function hasActiveSandboxEnvironment(): boolean {
+  const sandboxValue = process.env.PYRIC_SANDBOX;
+  if (sandboxValue === undefined) {
+    return false;
+  }
+  return sandboxValue.length > 0;
+}
+
+/**
+ * Verify whether the Next.js development server is booting under a secure,
+ * activated sandbox environment. Throws a protective terminal error if un-sandboxed.
+ */
+export function enforceSandboxGuard(options?: PyricNextOptions): void {
+  if (isGuardExplicitlyDisabled(options)) {
+    return;
+  }
+  if (hasActiveSandboxEnvironment()) {
+    return;
+  }
+  const errorMessage =
+    '[Pyric] Next.js development server started without active Pyric sandbox environment variables.\n' +
+    'To prevent accidental connections to production Firebase databases, launch this server using:\n' +
+    '  pyric dev -- next dev\n' +
+    'or source environment keys via `pyric env`.\n' +
+    'To disable this guard, pass { guard: false } to withPyric(config, options).';
+  throw new Error(errorMessage);
+}

package/src/next/index.ts

@@ -0,0 +1,16 @@
+/**
+ * `@pyric/cli/next` — the dev-only Next.js configuration wrapper (`withPyric`)
+ * that configures module aliasing for Webpack & Turbopack, externalizes server
+ * SDKs for Node runtime loader interception, and establishes dev-time rewrites
+ * for Pyric sandbox socket & bridge communication.
+ *
+ *   import { withPyric } from '@pyric/cli/next';
+ *   export default withPyric({ /* your next config * / });
+ */
+export { withPyric } from './with-pyric.js';
+export type {
+  PyricNextOptions,
+  NextConfig,
+  NextConfigObject,
+  NextConfigFunction,
+} from './types.js';

package/src/next/runtime-env.ts

@@ -0,0 +1,18 @@
+/**
+ * Augment Next.js configuration environment variables to pass Pyric runtime
+ * options (such as chip state) down into browser client builds.
+ */
+import type { NextConfigObject, PyricNextOptions } from './types.js';
+import { runtimeChipMetaValue } from '../serve/runtime/chip-config.js';
+
+export function augmentRuntimeEnv(config: NextConfigObject, options?: PyricNextOptions): NextConfigObject {
+  if (options === undefined || options.runtimeChip === undefined) {
+    return config;
+  }
+  const updatedConfig: NextConfigObject = Object.assign({}, config);
+  const existingEnv = updatedConfig.env !== undefined ? Object.assign({}, updatedConfig.env) : {};
+  const chipValue = runtimeChipMetaValue(options.runtimeChip);
+  existingEnv.PYRIC_RUNTIME_CHIP = chipValue;
+  updatedConfig.env = existingEnv;
+  return updatedConfig;
+}

package/src/next/server-external-packages.ts

@@ -0,0 +1,43 @@
+/**
+ * Server module externalization logic for Next.js runtime loader interception.
+ */
+import type { NextConfigObject } from './types.js';
+
+const TARGET_SERVER_PACKAGES = ['firebase', 'firebase-admin'];
+
+function appendExternalPackages(existingPackages?: unknown): string[] {
+  const packageSet = new Set<string>();
+  if (Array.isArray(existingPackages)) {
+    for (const pkg of existingPackages) {
+      if (typeof pkg === 'string') {
+        packageSet.add(pkg);
+      }
+    }
+  }
+  for (const pkg of TARGET_SERVER_PACKAGES) {
+    packageSet.add(pkg);
+  }
+  return Array.from(packageSet);
+}
+
+/**
+ * Inject Pyric backend target packages into `serverExternalPackages` so Next.js
+ * avoids inlining them during Server Component and API Route bundling.
+ */
+export function augmentServerExternalPackages(config: NextConfigObject): NextConfigObject {
+  const updatedConfig: NextConfigObject = Object.assign({}, config);
+
+  const currentExternalPackages = updatedConfig.serverExternalPackages;
+  updatedConfig.serverExternalPackages = appendExternalPackages(currentExternalPackages);
+
+  const hasExperimentalSection = typeof updatedConfig.experimental === 'object' && updatedConfig.experimental !== null;
+  const shouldAugmentLegacySection = hasExperimentalSection || updatedConfig.serverExternalPackages === undefined;
+  if (shouldAugmentLegacySection) {
+    const experimentalSection = hasExperimentalSection ? Object.assign({}, updatedConfig.experimental) : {};
+    const legacyPackages = experimentalSection.serverComponentsExternalPackages;
+    experimentalSection.serverComponentsExternalPackages = appendExternalPackages(legacyPackages);
+    updatedConfig.experimental = experimentalSection;
+  }
+
+  return updatedConfig;
+}

package/src/next/target-url.ts

@@ -0,0 +1,46 @@
+/**
+ * Resolution logic for determining the local Pyric dev server URL.
+ */
+import type { PyricNextOptions } from './types.js';
+
+const DEFAULT_LOOPBACK_HOST = 'http://127.0.0.1';
+const DEFAULT_SANDBOX_PORT = 4000;
+const REMOTE_PREFIX = 'remote:';
+
+function stripTrailingSlash(url: string): string {
+  if (url.endsWith('/')) {
+    return url.slice(0, -1);
+  }
+  return url;
+}
+
+/**
+ * Resolve the destination URL for Next.js dev-time rewrites using explicit
+ * fallback precedence: option URL → option port → PYRIC_SANDBOX remote URL →
+ * PYRIC_SANDBOX_PORT → default port 4000.
+ */
+export function resolveSandboxTargetUrl(options?: PyricNextOptions): string {
+  if (options !== undefined && options.url !== undefined) {
+    return stripTrailingSlash(options.url);
+  }
+
+  if (options !== undefined && options.port !== undefined) {
+    return `${DEFAULT_LOOPBACK_HOST}:${options.port}`;
+  }
+
+  const envSandbox = process.env.PYRIC_SANDBOX;
+  if (envSandbox !== undefined && envSandbox.startsWith(REMOTE_PREFIX)) {
+    const rawRemoteUrl = envSandbox.slice(REMOTE_PREFIX.length);
+    return stripTrailingSlash(rawRemoteUrl);
+  }
+
+  const envPort = process.env.PYRIC_SANDBOX_PORT;
+  if (envPort !== undefined) {
+    const parsedPort = Number(envPort);
+    if (!Number.isNaN(parsedPort)) {
+      return `${DEFAULT_LOOPBACK_HOST}:${parsedPort}`;
+    }
+  }
+
+  return `${DEFAULT_LOOPBACK_HOST}:${DEFAULT_SANDBOX_PORT}`;
+}

package/src/next/turbopack-config.ts

@@ -0,0 +1,54 @@
+/**
+ * Turbopack configuration augmentation for Next.js client SDK aliases.
+ */
+import type { NextConfigObject } from './types.js';
+import { getClientAliases } from './client-aliases.js';
+
+function assembleTurbopackAliases(existingTurbo: Record<string, any> | undefined): Record<string, any> {
+  const turboSection = existingTurbo !== undefined ? Object.assign({}, existingTurbo) : {};
+  const currentAliases = turboSection.resolveAlias !== undefined ? Object.assign({}, turboSection.resolveAlias) : {};
+  const pyricAliases = getClientAliases();
+  turboSection.resolveAlias = Object.assign(currentAliases, pyricAliases);
+  return turboSection;
+}
+
+/**
+ * Configure Turbopack module aliases across standard and experimental sections.
+ */
+export function augmentTurbopackConfig(config: NextConfigObject): NextConfigObject {
+  const updatedConfig: NextConfigObject = Object.assign({}, config);
+  const hasModernTurbopack = typeof updatedConfig.turbopack === 'object' && updatedConfig.turbopack !== null;
+  const hasLegacyTopLevelTurbo = typeof updatedConfig.turbo === 'object' && updatedConfig.turbo !== null;
+  const hasExperimentalTurbo =
+    typeof updatedConfig.experimental === 'object' &&
+    updatedConfig.experimental !== null &&
+    typeof updatedConfig.experimental.turbo === 'object' &&
+    updatedConfig.experimental.turbo !== null;
+
+  const shouldDefaultToModernTurbopack =
+    !hasModernTurbopack && !hasLegacyTopLevelTurbo && !hasExperimentalTurbo;
+
+  if (hasModernTurbopack || shouldDefaultToModernTurbopack) {
+    const currentTurbopack = updatedConfig.turbopack;
+    updatedConfig.turbopack = assembleTurbopackAliases(currentTurbopack);
+  }
+
+  if (hasLegacyTopLevelTurbo) {
+    const currentTurbo = updatedConfig.turbo;
+    updatedConfig.turbo = assembleTurbopackAliases(currentTurbo);
+  }
+
+  if (hasExperimentalTurbo) {
+    const existingExperimental =
+      typeof updatedConfig.experimental === 'object' && updatedConfig.experimental !== null
+        ? Object.assign({}, updatedConfig.experimental)
+        : {};
+    const currentTurbo = existingExperimental.turbo;
+    existingExperimental.turbo = assembleTurbopackAliases(currentTurbo);
+    updatedConfig.experimental = existingExperimental;
+  }
+
+  return updatedConfig;
+}
+
+

package/src/next/types.ts

@@ -0,0 +1,47 @@
+/**
+ * Public configuration types for the `@pyric/cli/next` integration.
+ */
+
+import type { PyricRuntimeChipOption } from '../serve/runtime/chip-config.js';
+export type { PyricRuntimeChipOption };
+
+export interface PyricNextOptions {
+  /**
+   * Guard against starting Next.js dev server directly (`next dev`) without
+   * active Pyric sandbox environment variables. When `true` (default), throws
+   * an early error if `PYRIC_SANDBOX` is missing during development builds.
+   * Pass `false` to opt out of safety checking.
+   */
+  guard?: boolean;
+  /**
+   * Port override for the local Pyric sandbox server when configuring dev-time
+   * rewrites (`/__pyric/:path*`). By default, resolves from `PYRIC_SANDBOX`
+   * or `PYRIC_SANDBOX_PORT`, falling back to `4000`.
+   */
+  port?: number;
+  /**
+   * Explicit URL override for the local Pyric sandbox server when configuring
+   * dev-time rewrites (e.g., `http://localhost:4000`).
+   */
+  url?: string;
+  /**
+   * Whether to configure Next.js dev-time rewrites to proxy `/__pyric/:path*`
+   * traffic to the local Pyric dev server. Default `true`.
+   */
+  rewrites?: boolean;
+  /**
+   * Display the floating Pyric runtime chip in browser client pages during
+   * local development. On by default. Pass `false` to hide it, or
+   * `{ initiallyOpen: true }` when actively debugging runtime errors.
+   */
+  runtimeChip?: PyricRuntimeChipOption;
+}
+
+export type NextConfigObject = Record<string, any>;
+
+export type NextConfigFunction = (
+  phase: string,
+  defaults: Record<string, any>,
+) => NextConfigObject | Promise<NextConfigObject>;
+
+export type NextConfig = NextConfigObject | NextConfigFunction;

package/src/next/webpack-config.ts

@@ -0,0 +1,71 @@
+/**
+ * Webpack configuration augmentation for Next.js client component builds.
+ */
+import type { NextConfigObject } from './types.js';
+import { getClientAliases, getNodeBuiltinFallbacks } from './client-aliases.js';
+
+interface WebpackOptions {
+  isServer: boolean;
+  [key: string]: unknown;
+}
+
+function isClientSideBuild(options: WebpackOptions): boolean {
+  return options.isServer === false;
+}
+
+function assembleClientResolveSection(existingResolve: Record<string, any> | undefined): Record<string, any> {
+  const resolveSection = existingResolve !== undefined ? Object.assign({}, existingResolve) : {};
+
+  const currentAliases = resolveSection.alias !== undefined ? Object.assign({}, resolveSection.alias) : {};
+  const newAliases = getClientAliases();
+  resolveSection.alias = Object.assign(currentAliases, newAliases);
+
+  const currentFallbacks = resolveSection.fallback !== undefined ? Object.assign({}, resolveSection.fallback) : {};
+  const newFallbacks = getNodeBuiltinFallbacks();
+  resolveSection.fallback = Object.assign(currentFallbacks, newFallbacks);
+
+  return resolveSection;
+}
+
+function assembleClientExperimentsSection(existingExperiments: Record<string, any> | undefined): Record<string, any> {
+  const experimentsSection = existingExperiments !== undefined ? Object.assign({}, existingExperiments) : {};
+  experimentsSection.topLevelAwait = true;
+  return experimentsSection;
+}
+
+function assembleClientOutputSection(existingOutput: Record<string, any> | undefined): Record<string, any> {
+  const outputSection = existingOutput !== undefined ? Object.assign({}, existingOutput) : {};
+  const environmentSection = outputSection.environment !== undefined ? Object.assign({}, outputSection.environment) : {};
+  environmentSection.asyncFunction = true;
+  outputSection.environment = environmentSection;
+  return outputSection;
+}
+
+/**
+ * Wrap the existing Next.js Webpack configuration builder to inject client-side
+ * Firebase module aliases and modern async runtime compatibility settings when
+ * bundling for browser execution.
+ */
+export function augmentWebpackConfig(config: NextConfigObject): NextConfigObject {
+  const updatedConfig: NextConfigObject = Object.assign({}, config);
+  const originalWebpack = updatedConfig.webpack;
+
+  updatedConfig.webpack = (webpackConfig: any, webpackOptions: WebpackOptions) => {
+    if (isClientSideBuild(webpackOptions)) {
+      const currentResolve = webpackConfig.resolve;
+      webpackConfig.resolve = assembleClientResolveSection(currentResolve);
+
+      const currentExperiments = webpackConfig.experiments;
+      webpackConfig.experiments = assembleClientExperimentsSection(currentExperiments);
+
+      const currentOutput = webpackConfig.output;
+      webpackConfig.output = assembleClientOutputSection(currentOutput);
+    }
+    if (typeof originalWebpack === 'function') {
+      return originalWebpack(webpackConfig, webpackOptions);
+    }
+    return webpackConfig;
+  };
+
+  return updatedConfig;
+}

package/src/next/with-pyric.ts

@@ -0,0 +1,58 @@
+/**
+ * Core execution coordinator for the Next.js `withPyric` configuration wrapper.
+ */
+import type { NextConfig, NextConfigFunction, NextConfigObject, PyricNextOptions } from './types.js';
+import { enforceSandboxGuard, isProductionPassthrough } from './guard.js';
+import { augmentServerExternalPackages } from './server-external-packages.js';
+import { augmentWebpackConfig } from './webpack-config.js';
+import { augmentTurbopackConfig } from './turbopack-config.js';
+import { augmentDevRewrites } from './dev-rewrites.js';
+import { augmentRuntimeEnv } from './runtime-env.js';
+
+function isFunctionConfig(config: NextConfig): config is NextConfigFunction {
+  return typeof config === 'function';
+}
+
+function applyPyricEnhancements(config: NextConfigObject, options?: PyricNextOptions): NextConfigObject {
+  let enhancedConfig = augmentServerExternalPackages(config);
+  enhancedConfig = augmentWebpackConfig(enhancedConfig);
+  enhancedConfig = augmentTurbopackConfig(enhancedConfig);
+  enhancedConfig = augmentDevRewrites(enhancedConfig, options);
+  enhancedConfig = augmentRuntimeEnv(enhancedConfig, options);
+  return enhancedConfig;
+}
+
+/**
+ * Higher-order configuration wrapper for Next.js (`next.config.js` or `next.config.mjs`).
+ *
+ * During development mode (`pyric dev` or non-production NODE_ENV):
+ *   - Applies Webpack and Turbopack alias mappings to swap `firebase/*` imports
+ *     for Pyric local sandbox mirrors on client components.
+ *   - Adds `firebase` and `firebase-admin` to `serverExternalPackages` to prevent
+ *     inlining in Server Components and API routes, preserving `@pyric/cli/register` hooks.
+ *   - Configures dev-time rewrites (`/__pyric/*`) to proxy socket and bridge traffic
+ *     to the local Pyric server without CORS errors.
+ *   - Enforces a bundler safety interlock (guard) to prevent accidental connections to
+ *     production databases when `PYRIC_SANDBOX` is inactive.
+ *
+ * In production (`NODE_ENV === 'production'` without `PYRIC_SANDBOX_FORCE=1`):
+ *   - Functions as a zero-overhead identity passthrough, leaving standard builds untouched.
+ */
+export function withPyric(config: NextConfig = {}, options?: PyricNextOptions): NextConfig {
+  if (isProductionPassthrough()) {
+    return config;
+  }
+
+  enforceSandboxGuard(options);
+
+  if (isFunctionConfig(config)) {
+    const asyncConfigWrapper: NextConfigFunction = async (phase, defaults) => {
+      const resolvedConfig = await config(phase, defaults);
+      const augmentedConfig = applyPyricEnhancements(resolvedConfig, options);
+      return augmentedConfig;
+    };
+    return asyncConfigWrapper;
+  }
+
+  return applyPyricEnhancements(config, options);
+}

package/src/register/app-bridge.ts

@@ -0,0 +1,79 @@
+/** Node register adapter for canonical `firebase/app` imports when production AI pass-through is active. */
+import * as pyricApp from 'pyric/app/register';
+import * as realApp from 'firebase/app';
+
+function decorateApp(
+  app: pyricApp.FirebaseApp,
+  options?: pyricApp.FirebaseOptions,
+  rawSettings?: string | pyricApp.FirebaseAppSettings,
+): pyricApp.FirebaseApp {
+  try {
+    let shadow: { container?: unknown };
+    try {
+      shadow = realApp.getApp(app.name) as { container?: unknown };
+    } catch {
+      const initOptions = (options ?? app.options) as realApp.FirebaseOptions;
+      const initSettings = rawSettings ?? app.name;
+      const isStringSettings = typeof initSettings === 'string';
+      if (isStringSettings) {
+        shadow = realApp.initializeApp(initOptions, initSettings) as { container?: unknown };
+      } else {
+        const objectSettings = initSettings as realApp.FirebaseAppSettings;
+        shadow = realApp.initializeApp(initOptions, objectSettings) as { container?: unknown };
+      }
+    }
+    const hasShadowContainer = shadow.container !== undefined && shadow.container !== null;
+    if (hasShadowContainer) {
+      Object.defineProperty(app, 'container', { value: shadow.container, configurable: true });
+    }
+  } catch {
+    // Observational/best-effort: do not break Pyric initialization if shadow initialization fails.
+  }
+  return app;
+}
+
+export function initializeApp(
+  options?: pyricApp.FirebaseOptions,
+  rawSettings?: string | pyricApp.FirebaseAppSettings,
+): pyricApp.FirebaseApp {
+  const app = pyricApp.initializeApp(options, rawSettings);
+  return decorateApp(app, options, rawSettings);
+}
+
+export function getApp(name?: string): pyricApp.FirebaseApp {
+  return decorateApp(pyricApp.getApp(name));
+}
+
+export function getApps(): pyricApp.FirebaseApp[] {
+  return pyricApp.getApps().map((app) => decorateApp(app));
+}
+
+export async function deleteApp(app: pyricApp.FirebaseApp): Promise<void> {
+  try {
+    const shadow = realApp.getApp(app.name);
+    const hasShadow = shadow !== undefined && shadow !== null;
+    if (hasShadow) {
+      await realApp.deleteApp(shadow);
+    }
+  } catch {
+    // Ignore if shadow app was not initialized or already deleted.
+  }
+  return pyricApp.deleteApp(app);
+}
+
+export {
+  FirebaseError,
+  SDK_VERSION,
+  onLog,
+  registerVersion,
+  setLogLevel,
+} from 'pyric/app/register';
+export type {
+  FirebaseApp,
+  FirebaseAppSettings,
+  FirebaseOptions,
+  LogCallback,
+  LogEntry,
+  LogLevel,
+  LogOptions,
+} from 'pyric/app/register';

package/src/register/hooks.ts

@@ -26,5 +26,10 @@ export function resolve(
   context: ResolveContext,
   nextResolve: (specifier: string, context?: ResolveContext) => Promise<ResolveResult>,
 ): Promise<ResolveResult> {
-  return nextResolve(mapFirebaseSpecifier(specifier) ?? specifier, context);
+  const mappedSpecifier = mapFirebaseSpecifier(specifier, context.parentURL);
+  const hasMappedSpecifier = mappedSpecifier !== null && mappedSpecifier !== undefined;
+  if (hasMappedSpecifier) {
+    return nextResolve(mappedSpecifier, context);
+  }
+  return nextResolve(specifier, context);
 }

package/src/register/index.ts

@@ -92,7 +92,7 @@ function activate(): void {
   if (typeof moduleApi.registerHooks === 'function') {
     moduleApi.registerHooks({
       resolve(specifier, context, nextResolve) {
-        const mapped = mapFirebaseSpecifier(specifier);
+        const mapped = mapFirebaseSpecifier(specifier, context.parentURL);
         if (mapped === null) return nextResolve(specifier, context);
         try {
           return nextResolve(mapped, { ...context, parentURL: import.meta.url });