@absolutejs/absolute 0.19.0-beta.966 → 0.19.0-beta.968

package/dist/angular/index.js

@@ -174,7 +174,7 @@ var normalizeSlug = (str) => str.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-
     return str.charAt(0).toUpperCase() + str.slice(1);
   }
   return normalizeSlug(str).split(/[-_]/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase()).join("");
-}, toScreamingSnake = (str) => str.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();
+};
 
 // src/utils/registerClientScript.ts
 var scriptRegistry, requestCounter = 0, getRequestId = () => `req_${Date.now()}_${++requestCounter}`, ssrContextGetter = null, getSsrContextId = () => ssrContextGetter?.() || Object.getOwnPropertyDescriptor(globalThis, "__absolutejs_requestId")?.value, registerClientScript = (script, requestId) => {
@@ -512,37 +512,19 @@ var buildRequestProviders = (deps, request, requestContext, responseInit) => [
 ];
 
 // src/angular/ssrRender.ts
-var routePropsCache, cacheRouteData = (pagePath, data) => {
+var routeContextCache, cacheRouteData = (pagePath, data) => {
   const cacheKey = pagePath.split("?")[0] ?? pagePath;
-  routePropsCache.set(cacheKey, data);
-}, getCachedRouteData = (pagePath) => routePropsCache.get(pagePath), selectorCache, buildProviders = (deps, sanitizer, maybeProps, tokenMap, request, requestContext, responseInit, userProviders = []) => {
-  const providers = [
-    deps.provideServerRendering(),
-    deps.provideClientHydration(deps.withHttpTransferCacheOptions(buildAbsoluteHttpTransferCacheOptions())),
-    deps.provideZonelessChangeDetection(),
-    { provide: deps.APP_BASE_HREF, useValue: "/" },
-    {
-      provide: deps.DomSanitizer,
-      useValue: sanitizer
-    },
-    { provide: deps.Sanitizer, useValue: sanitizer },
-    ...buildRequestProviders(deps, request, requestContext, responseInit),
-    ...userProviders
-  ];
-  if (!maybeProps) {
-    return providers;
-  }
-  const propProviders = Object.entries(maybeProps).map(([propName, propValue]) => ({
-    token: tokenMap.get(toScreamingSnake(propName)),
-    value: propValue
-  })).filter((entry) => entry.token).map((entry) => ({ provide: entry.token, useValue: entry.value }));
-  return [...providers, ...propProviders];
-}, isInjectionToken = (value) => {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  return "ngMetadataName" in value && value.ngMetadataName === "InjectionToken";
-}, discoverTokens = (pageModule) => new Map(Object.entries(pageModule).filter(([, value]) => isInjectionToken(value))), resolveSelector = (deps, pagePath, PageComponent) => {
+  routeContextCache.set(cacheKey, data);
+}, getCachedRouteData = (pagePath) => routeContextCache.get(pagePath), selectorCache, buildProviders = (deps, sanitizer, request, requestContext, responseInit, userProviders = []) => [
+  deps.provideServerRendering(),
+  deps.provideClientHydration(deps.withHttpTransferCacheOptions(buildAbsoluteHttpTransferCacheOptions())),
+  deps.provideZonelessChangeDetection(),
+  { provide: deps.APP_BASE_HREF, useValue: "/" },
+  { provide: deps.DomSanitizer, useValue: sanitizer },
+  { provide: deps.Sanitizer, useValue: sanitizer },
+  ...buildRequestProviders(deps, request, requestContext, responseInit),
+  ...userProviders
+], resolveSelector = (deps, pagePath, PageComponent) => {
   const cached = selectorCache.get(pagePath);
   if (cached) {
     return cached;
@@ -558,14 +540,14 @@ var routePropsCache, cacheRouteData = (pagePath, data) => {
     return html.replace("</html>", `${snippet}</html>`);
   }
   return html + snippet;
-}, injectSsrScripts = (html, requestId, indexPath, props) => {
+}, injectSsrScripts = (html, requestId, indexPath, requestContext) => {
   let result = html;
   const registeredScripts = getAndClearClientScripts(requestId);
   if (registeredScripts.length > 0) {
     result = injectBeforeClose(result, generateClientScriptCode(registeredScripts));
   }
-  if (props) {
-    result = injectBeforeClose(result, `<script>window.__ABS_ANGULAR_PAGE_PROPS__ = ${JSON.stringify(props)};</script>`);
+  if (requestContext !== undefined) {
+    result = injectBeforeClose(result, `<script>window.__ABS_ANGULAR_REQUEST_CONTEXT__ = ${JSON.stringify(requestContext)};</script>`);
   }
   if (indexPath) {
     const escapedIndexPath = JSON.stringify(indexPath);
@@ -595,7 +577,7 @@ var routePropsCache, cacheRouteData = (pagePath, data) => {
 };
 var init_ssrRender = __esm(() => {
   init_registerClientScript();
-  routePropsCache = new Map;
+  routeContextCache = new Map;
   selectorCache = new Map;
 });
 
@@ -2978,6 +2960,16 @@ var init_logger = __esm(() => {
   };
 });
 
+// src/utils/generatedDir.ts
+var exports_generatedDir = {};
+__export(exports_generatedDir, {
+  getGeneratedRoot: () => getGeneratedRoot,
+  getFrameworkGeneratedDir: () => getFrameworkGeneratedDir
+});
+import { join as join6 } from "path";
+var GENERATED_DIR_NAME = "generated", ABSOLUTE_CACHE_DIR_NAME = ".absolutejs", getGeneratedRoot = (projectRoot = process.cwd()) => join6(projectRoot, ABSOLUTE_CACHE_DIR_NAME, GENERATED_DIR_NAME), getFrameworkGeneratedDir = (framework, projectRoot = process.cwd()) => join6(getGeneratedRoot(projectRoot), framework);
+var init_generatedDir = () => {};
+
 // src/islands/sourceMetadata.ts
 var islandFrameworks2, islandHydrationModes2, isIslandFramework2 = (value) => islandFrameworks2.some((framework) => framework === value), isIslandHydrate2 = (value) => islandHydrationModes2.some((hydrate) => hydrate === value), parseIslandTagAttributes = (attributeString) => {
   const frameworkMatch = attributeString.match(/\bframework\s*=\s*["']([^"']+)["']/);
@@ -3516,16 +3508,6 @@ var init_lowerDeferSyntax = __esm(() => {
   init_constants();
 });
 
-// src/utils/generatedDir.ts
-var exports_generatedDir = {};
-__export(exports_generatedDir, {
-  getGeneratedRoot: () => getGeneratedRoot,
-  getFrameworkGeneratedDir: () => getFrameworkGeneratedDir
-});
-import { join as join6 } from "path";
-var GENERATED_DIR_NAME = "generated", ABSOLUTE_CACHE_DIR_NAME = ".absolutejs", getGeneratedRoot = (projectRoot = process.cwd()) => join6(projectRoot, ABSOLUTE_CACHE_DIR_NAME, GENERATED_DIR_NAME), getFrameworkGeneratedDir = (framework, projectRoot = process.cwd()) => join6(getGeneratedRoot(projectRoot), framework);
-var init_generatedDir = () => {};
-
 // src/build/compileAngular.ts
 var exports_compileAngular = {};
 __export(exports_compileAngular, {
@@ -3535,8 +3517,8 @@ __export(exports_compileAngular, {
   compileAngularFile: () => compileAngularFile,
   compileAngular: () => compileAngular
 });
-import { existsSync as existsSync4, readFileSync as readFileSync4, promises as fs } from "fs";
-import { join as join7, basename as basename3, sep, dirname as dirname4, resolve as resolve6, relative as relative4 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4, promises as fs } from "fs";
+import { join as join8, basename as basename3, sep, dirname as dirname4, resolve as resolve6, relative as relative4 } from "path";
 var {Glob } = globalThis.Bun;
 import ts from "typescript";
 var traceAngularPhase = async (name, fn, metadata) => {
@@ -3579,12 +3561,12 @@ var traceAngularPhase = async (name, fn, metadata) => {
     `${candidate}.tsx`,
     `${candidate}.js`,
     `${candidate}.jsx`,
-    join7(candidate, "index.ts"),
-    join7(candidate, "index.tsx"),
-    join7(candidate, "index.js"),
-    join7(candidate, "index.jsx")
+    join8(candidate, "index.ts"),
+    join8(candidate, "index.tsx"),
+    join8(candidate, "index.js"),
+    join8(candidate, "index.jsx")
   ];
-  return candidates.find((file) => existsSync4(file));
+  return candidates.find((file) => existsSync5(file));
 }, createLegacyAngularAnimationUsageResolver = (rootDir) => {
   const baseDir = resolve6(rootDir);
   const tsconfigAliases = readTsconfigPathAliases();
@@ -3618,9 +3600,9 @@ var traceAngularPhase = async (name, fn, metadata) => {
       });
     }
     const resolved = resolve6(actualPath);
-    const cached = scanCache.get(resolved);
-    if (cached)
-      return cached;
+    const cached2 = scanCache.get(resolved);
+    if (cached2)
+      return cached2;
     const promise = (async () => {
       let sourceCode;
       try {
@@ -3665,11 +3647,11 @@ var traceAngularPhase = async (name, fn, metadata) => {
 }, resolveDevClientDir = () => {
   const projectRoot = process.cwd();
   const fromSource = resolve6(import.meta.dir, "../dev/client");
-  if (existsSync4(fromSource) && fromSource.startsWith(projectRoot)) {
+  if (existsSync5(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
   const fromNodeModules = resolve6(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
-  if (existsSync4(fromNodeModules))
+  if (existsSync5(fromNodeModules))
     return fromNodeModules;
   return resolve6(import.meta.dir, "./dev/client");
 }, devClientDir, hmrClientPath, formatDiagnosticMessage = (diagnostic) => {
@@ -3715,11 +3697,11 @@ var traceAngularPhase = async (name, fn, metadata) => {
     return `${path}${query}`;
   const importerDir = dirname4(importerOutputPath);
   const fileCandidate = resolve6(importerDir, `${path}.js`);
-  if (outputFiles?.has(fileCandidate) || existsSync4(fileCandidate)) {
+  if (outputFiles?.has(fileCandidate) || existsSync5(fileCandidate)) {
     return `${path}.js${query}`;
   }
   const indexCandidate = resolve6(importerDir, path, "index.js");
-  if (outputFiles?.has(indexCandidate) || existsSync4(indexCandidate)) {
+  if (outputFiles?.has(indexCandidate) || existsSync5(indexCandidate)) {
     return `${path}/index.js${query}`;
   }
   return `${path}.js${query}`;
@@ -3752,12 +3734,12 @@ var traceAngularPhase = async (name, fn, metadata) => {
     `${basePath}.tsx`,
     `${basePath}.mts`,
     `${basePath}.cts`,
-    join7(basePath, "index.ts"),
-    join7(basePath, "index.tsx"),
-    join7(basePath, "index.mts"),
-    join7(basePath, "index.cts")
+    join8(basePath, "index.ts"),
+    join8(basePath, "index.tsx"),
+    join8(basePath, "index.mts"),
+    join8(basePath, "index.cts")
   ];
-  return candidates.map((candidate) => resolve6(candidate)).find((candidate) => existsSync4(candidate) && !candidate.endsWith(".d.ts")) ?? null;
+  return candidates.map((candidate) => resolve6(candidate)).find((candidate) => existsSync5(candidate) && !candidate.endsWith(".d.ts")) ?? null;
 }, readFileForAotTransform = async (fileName, readFile2) => {
   const hostSource = readFile2?.(fileName);
   if (typeof hostSource === "string")
@@ -3781,15 +3763,15 @@ var traceAngularPhase = async (name, fn, metadata) => {
   const paths = [];
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1])
-    paths.push(join7(fileDir, templateUrlMatch[1]));
+    paths.push(join8(fileDir, templateUrlMatch[1]));
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (styleUrlMatch?.[1])
-    paths.push(join7(fileDir, styleUrlMatch[1]));
+    paths.push(join8(fileDir, styleUrlMatch[1]));
   const styleUrlsMatch = findUncommentedMatch(source, /styleUrls\s*:\s*\[([^\]]+)\]/);
   const urlMatches = styleUrlsMatch?.[1]?.match(/['"]([^'"]+)['"]/g);
   if (urlMatches) {
     for (const urlMatch of urlMatches) {
-      paths.push(join7(fileDir, urlMatch.replace(/['"]/g, "")));
+      paths.push(join8(fileDir, urlMatch.replace(/['"]/g, "")));
     }
   }
   return paths.map((path) => resolve6(path));
@@ -3823,7 +3805,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
     safeStableStringify(stylePreprocessors ?? null)
   ].join("\x00");
   const cacheKey = Bun.hash(cacheInput).toString(BASE_36_RADIX);
-  return join7(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey}.json`);
+  return join8(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey}.json`);
 }, precomputeAotResourceTransforms = async (inputPaths, readFile2, stylePreprocessors) => {
   const transformedSources = new Map;
   const visited = new Set;
@@ -3838,16 +3820,16 @@ var traceAngularPhase = async (name, fn, metadata) => {
     if (visited.has(resolvedPath))
       return;
     visited.add(resolvedPath);
-    if (!existsSync4(resolvedPath) || resolvedPath.endsWith(".d.ts"))
+    if (!existsSync5(resolvedPath) || resolvedPath.endsWith(".d.ts"))
       return;
     stats.filesVisited += 1;
     const source = await readFileForAotTransform(resolvedPath, readFile2);
     const cachePath = await resolveResourceTransformCachePath(resolvedPath, source, stylePreprocessors);
-    const cached = await readResourceCacheFile(cachePath);
+    const cached2 = await readResourceCacheFile(cachePath);
     let transformedSource;
-    if (cached) {
+    if (cached2) {
       stats.cacheHits += 1;
-      transformedSource = cached.source;
+      transformedSource = cached2.source;
     } else {
       stats.cacheMisses += 1;
       const transformed = await inlineResources(source, dirname4(resolvedPath), stylePreprocessors);
@@ -3869,7 +3851,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
   return { stats, transformedSources };
 }, compileAngularFiles = async (inputPaths, outDir, stylePreprocessors) => {
   const islandMetadataByOutputPath = await traceAngularPhase("aot/island-metadata", () => new Map(inputPaths.map((inputPath) => {
-    const outputPath = resolve6(join7(outDir, relative4(process.cwd(), resolve6(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
+    const outputPath = resolve6(join8(outDir, relative4(process.cwd(), resolve6(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
     return [
       outputPath,
       buildIslandMetadataExports(readFileSync4(inputPath, "utf-8"))
@@ -3916,7 +3898,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
   const originalGetSourceFile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
     if (fileName.startsWith("lib.") && fileName.endsWith(".d.ts") && tsLibDir) {
-      const resolvedPath = join7(tsLibDir, fileName);
+      const resolvedPath = join8(tsLibDir, fileName);
       return originalGetSourceFile?.call(host, resolvedPath, languageVersion, onError);
     }
     return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
@@ -3971,7 +3953,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
   const entries = await traceAngularPhase("aot/postprocess-emitted-js", () => {
     const rawEntries = Object.entries(emitted).filter(([fileName]) => fileName.endsWith(".js")).map(([fileName, content]) => ({
       content,
-      target: join7(outDir, fileName)
+      target: join8(outDir, fileName)
     }));
     const outputFiles = new Set(rawEntries.map(({ target }) => resolve6(target)));
     return rawEntries.map(({ content, target }) => {
@@ -4012,7 +3994,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
   return null;
 }, resolveAngularDeferImportSpecifier = () => {
   const sourceEntry = resolve6(import.meta.dir, "../angular/components/index.ts");
-  if (existsSync4(sourceEntry)) {
+  if (existsSync5(sourceEntry)) {
     return sourceEntry.replace(/\\/g, "/");
   }
   return "@absolutejs/absolute/angular/components";
@@ -4140,7 +4122,7 @@ ${slot.resolvedBindings.map((binding) => `		"${binding.key}": this.__absoluteDef
 ${fields}
 `);
 }, readAndEscapeFile = async (filePath, stylePreprocessors) => {
-  if (!existsSync4(filePath)) {
+  if (!existsSync5(filePath)) {
     throw new Error(`Unable to inline Angular style resource: file not found at ${filePath}`);
   }
   const content = await compileStyleFileIfNeeded(filePath, stylePreprocessors);
@@ -4148,8 +4130,8 @@ ${fields}
 }, inlineTemplateAndLowerDefer = async (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join7(fileDir, templateUrlMatch[1]);
-    if (!existsSync4(templatePath)) {
+    const templatePath = join8(fileDir, templateUrlMatch[1]);
+    if (!existsSync5(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
     const templateRaw2 = await fs.readFile(templatePath, "utf-8");
@@ -4179,8 +4161,8 @@ ${fields}
 }, inlineTemplateAndLowerDeferSync = (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join7(fileDir, templateUrlMatch[1]);
-    if (!existsSync4(templatePath)) {
+    const templatePath = join8(fileDir, templateUrlMatch[1]);
+    if (!existsSync5(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
     const templateRaw2 = readFileSync4(templatePath, "utf-8");
@@ -4216,7 +4198,7 @@ ${fields}
     return source;
   const stylePromises = urlMatches.map((urlMatch) => {
     const styleUrl = urlMatch.replace(/['"]/g, "");
-    return readAndEscapeFile(join7(fileDir, styleUrl), stylePreprocessors);
+    return readAndEscapeFile(join8(fileDir, styleUrl), stylePreprocessors);
   });
   const results = await Promise.all(stylePromises);
   const inlinedStyles = results.filter(Boolean).map((escaped) => `\`${escaped}\``);
@@ -4227,7 +4209,7 @@ ${fields}
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (!styleUrlMatch?.[1])
     return source;
-  const escaped = await readAndEscapeFile(join7(fileDir, styleUrlMatch[1]), stylePreprocessors);
+  const escaped = await readAndEscapeFile(join8(fileDir, styleUrlMatch[1]), stylePreprocessors);
   if (!escaped)
     return source;
   return source.slice(0, styleUrlMatch.index) + `styles: [\`${escaped}\`]` + source.slice(styleUrlMatch.index + styleUrlMatch[0].length);
@@ -4263,12 +4245,12 @@ ${fields}
       `${candidate}.js`,
       `${candidate}.jsx`,
       `${candidate}.json`,
-      join7(candidate, "index.ts"),
-      join7(candidate, "index.tsx"),
-      join7(candidate, "index.js"),
-      join7(candidate, "index.jsx")
+      join8(candidate, "index.ts"),
+      join8(candidate, "index.tsx"),
+      join8(candidate, "index.js"),
+      join8(candidate, "index.jsx")
     ];
-    return candidates.find((file) => existsSync4(file));
+    return candidates.find((file) => existsSync5(file));
   };
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
@@ -4293,7 +4275,7 @@ ${fields}
     const inputDir = dirname4(sourcePath);
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
     const fileBase = basename3(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
-    return join7(outDir, relativeDir, fileBase);
+    return join8(outDir, relativeDir, fileBase);
   };
   const withCacheBuster = (specifier) => {
     if (!cacheBuster)
@@ -4340,11 +4322,11 @@ ${fields}
     if (visited.has(resolved))
       return;
     visited.add(resolved);
-    if (resolved.endsWith(".json") && existsSync4(resolved)) {
+    if (resolved.endsWith(".json") && existsSync5(resolved)) {
       const inputDir2 = dirname4(resolved);
       const relativeDir2 = inputDir2.startsWith(baseDir) ? inputDir2.substring(baseDir.length + 1) : inputDir2;
-      const targetDir2 = join7(outDir, relativeDir2);
-      const targetPath2 = join7(targetDir2, basename3(resolved));
+      const targetDir2 = join8(outDir, relativeDir2);
+      const targetPath2 = join8(targetDir2, basename3(resolved));
       await fs.mkdir(targetDir2, { recursive: true });
       await fs.copyFile(resolved, targetPath2);
       allOutputs.push(targetPath2);
@@ -4353,7 +4335,7 @@ ${fields}
     let actualPath = resolved;
     if (!actualPath.endsWith(".ts"))
       actualPath += ".ts";
-    if (!existsSync4(actualPath))
+    if (!existsSync5(actualPath))
       return;
     let sourceCode = await fs.readFile(actualPath, "utf-8");
     const inlined = await inlineResources(sourceCode, dirname4(actualPath), stylePreprocessors);
@@ -4361,7 +4343,7 @@ ${fields}
     const inputDir = dirname4(actualPath);
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
     const fileBase = basename3(actualPath).replace(/\.[cm]?[tj]sx?$/, ".js");
-    const targetDir = join7(outDir, relativeDir);
+    const targetDir = join8(outDir, relativeDir);
     const targetPath = toOutputPath(actualPath);
     const localImports = [];
     const importRewrites = new Map;
@@ -4391,7 +4373,7 @@ ${fields}
     const isEntry = resolve6(actualPath) === resolve6(entryPath);
     const contentHash = Bun.hash(sourceCode).toString(BASE_36_RADIX);
     const cacheKey = actualPath;
-    const shouldWriteFile = cacheBuster && isEntry ? true : jitContentCache.get(cacheKey) !== contentHash || !existsSync4(targetPath);
+    const shouldWriteFile = cacheBuster && isEntry ? true : jitContentCache.get(cacheKey) !== contentHash || !existsSync5(targetPath);
     if (shouldWriteFile) {
       const processedContent = transpileAndRewrite(sourceCode, relativeDir, actualPath, importRewrites);
       await fs.mkdir(targetDir, { recursive: true });
@@ -4403,7 +4385,7 @@ ${fields}
   };
   await transpileFile(inputPath);
   const entryOutputPath = toOutputPath(entryPath);
-  if (existsSync4(entryOutputPath)) {
+  if (existsSync5(entryOutputPath)) {
     const entryOutput = await fs.readFile(entryOutputPath, "utf-8");
     const withoutLegacyFlag = entryOutput.replace(/\nexport const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;\n?/g, `
 `);
@@ -4422,23 +4404,23 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     return { clientPaths: [...emptyPaths], serverPaths: [...emptyPaths] };
   }
   const compiledRoot = compiledParent;
-  const indexesDir = join7(compiledParent, "indexes");
+  const indexesDir = join8(compiledParent, "indexes");
   await traceAngularPhase("setup/create-indexes-dir", () => fs.mkdir(indexesDir, { recursive: true }));
   const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve6(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
   if (!hmr) {
     await traceAngularPhase("aot/copy-json-resources", async () => {
       const cwd = process.cwd();
       const angularSrcDir = resolve6(outRoot);
-      if (!existsSync4(angularSrcDir))
+      if (!existsSync5(angularSrcDir))
         return;
       const jsonGlob = new Glob("**/*.json");
       for (const rel of jsonGlob.scanSync({
         absolute: false,
         cwd: angularSrcDir
       })) {
-        const sourcePath = join7(angularSrcDir, rel);
+        const sourcePath = join8(angularSrcDir, rel);
         const cwdRel = relative4(cwd, sourcePath);
-        const targetPath = join7(compiledRoot, cwdRel);
+        const targetPath = join8(compiledRoot, cwdRel);
         await fs.mkdir(dirname4(targetPath), { recursive: true });
         await fs.copyFile(sourcePath, targetPath);
       }
@@ -4455,24 +4437,24 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const fileBase = basename3(resolvedEntry).replace(/\.[tj]s$/, "");
     const jsName = `${fileBase}.js`;
     const compiledFallbackPaths = [
-      join7(compiledRoot, relativeEntry),
-      join7(compiledRoot, "pages", jsName),
-      join7(compiledRoot, jsName)
+      join8(compiledRoot, relativeEntry),
+      join8(compiledRoot, "pages", jsName),
+      join8(compiledRoot, jsName)
     ].map((file) => resolve6(file));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
         ...candidatePaths.map((file) => resolve6(file)),
         ...compiledFallbackPaths
       ];
-      let candidate = normalizedCandidates.find((file) => existsSync4(file) && file.endsWith(`${sep}${relativeEntry}`));
+      let candidate = normalizedCandidates.find((file) => existsSync5(file) && file.endsWith(`${sep}${relativeEntry}`));
       if (!candidate) {
-        candidate = normalizedCandidates.find((file) => existsSync4(file) && file.endsWith(`${sep}pages${sep}${jsName}`));
+        candidate = normalizedCandidates.find((file) => existsSync5(file) && file.endsWith(`${sep}pages${sep}${jsName}`));
       }
       if (!candidate) {
-        candidate = normalizedCandidates.find((file) => existsSync4(file) && file.endsWith(`${sep}${jsName}`));
+        candidate = normalizedCandidates.find((file) => existsSync5(file) && file.endsWith(`${sep}${jsName}`));
       }
       if (!candidate) {
-        candidate = normalizedCandidates.find((file) => existsSync4(file));
+        candidate = normalizedCandidates.find((file) => existsSync5(file));
       }
       return candidate;
     };
@@ -4480,11 +4462,11 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     if (!rawServerFile) {
       rawServerFile = await traceAngularPhase("wrapper/resolve-server-output-fallback", () => resolveRawServerFile([]), { entry: resolvedEntry });
     }
-    if (rawServerFile && !existsSync4(rawServerFile)) {
+    if (rawServerFile && !existsSync5(rawServerFile)) {
       outputs = hmr ? await compileEntry() : aotOutputs;
       rawServerFile = await traceAngularPhase("wrapper/resolve-server-output-retry", () => resolveRawServerFile(outputs), { entry: resolvedEntry });
     }
-    if (!rawServerFile || !existsSync4(rawServerFile)) {
+    if (!rawServerFile || !existsSync5(rawServerFile)) {
       throw new Error(`Compiled output not found for ${entry}. Looking for: ${jsName}. Available: ${[
         ...outputs,
         ...compiledFallbackPaths
@@ -4505,8 +4487,8 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const usesLegacyAnimations = await traceAngularPhase("wrapper/detect-legacy-animations", () => usesLegacyAngularAnimations(resolvedEntry), { entry: resolvedEntry });
     const serverContentHash = Bun.hash(original).toString(BASE_36_RADIX);
     const cachedWrapper = wrapperOutputCache.get(resolvedEntry);
-    const clientFile = join7(indexesDir, jsName);
-    if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync4(clientFile) && (usesLegacyAnimations || !original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__")) && (!usesLegacyAnimations || original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__"))) {
+    const clientFile = join8(indexesDir, jsName);
+    if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync5(clientFile) && (usesLegacyAnimations || !original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__")) && (!usesLegacyAnimations || original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__"))) {
       return {
         clientPath: clientFile,
         indexUnchanged: true,
@@ -4533,6 +4515,14 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     await traceAngularPhase("wrapper/write-server-output", () => fs.writeFile(rawServerFile, rewritten, "utf-8"), { entry: resolvedEntry });
     const relativePath = relative4(indexesDir, rawServerFile).replace(/\\/g, "/");
     const normalizedImportPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+    const manifestKeyForProviders = toPascal(fileBase);
+    const providersFilePath = join8(compiledParent, "providers", `${manifestKeyForProviders}.providers.ts`);
+    const hasGeneratedProviders = existsSync5(providersFilePath);
+    const providersImportPath = hasGeneratedProviders ? (() => {
+      const rel = relative4(indexesDir, providersFilePath.replace(/\.ts$/, "")).replace(/\\/g, "/");
+      return rel.startsWith(".") ? rel : `./${rel}`;
+    })() : null;
+    const generatedProvidersImport = providersImportPath ? `import { providers as generatedProviders } from '${providersImportPath}';` : "var generatedProviders = null;";
     const hmrPreamble = hmr ? `window.__HMR_FRAMEWORK__ = "angular";
 import "${hmrClientPath}";
 ` : "";
@@ -4541,32 +4531,31 @@ import '@angular/compiler';
 import { bootstrapApplication } from '@angular/platform-browser';
 import { provideClientHydration } from '@angular/platform-browser';
 import { withHttpTransferCacheOptions } from '@angular/platform-browser';
-import { provideZonelessChangeDetection } from '@angular/core';
+import { provideZonelessChangeDetection, REQUEST_CONTEXT } from '@angular/core';
 import * as pageModule from '${normalizedImportPath}';
+${generatedProvidersImport}
 
 var ${componentClassName} = pageModule.default;
-var toScreamingSnake = function(str) {
-    return str.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase();
-};
-var isInjectionToken = function(value) {
-    return Boolean(value) && typeof value === 'object' && value.ngMetadataName === 'InjectionToken';
-};
-var pageProps = window.__ABS_ANGULAR_PAGE_PROPS__ || {};
+// REQUEST_CONTEXT is hydrated from the SSR-serialized payload so client-side
+// \`inject(REQUEST_CONTEXT)\` (or \`usePageContext<T>()\`) returns the same
+// object the server rendered with \u2014 no second round-trip, no transferState
+// dance for callers.
+var requestContext = Object.prototype.hasOwnProperty.call(window, '__ABS_ANGULAR_REQUEST_CONTEXT__')
+    ? window.__ABS_ANGULAR_REQUEST_CONTEXT__
+    : null;
 var pageHasIslands = Boolean(pageModule.__ABSOLUTE_PAGE_HAS_ISLANDS__) || Boolean(document.querySelector('[data-island="true"]'));
 var pageHasRawStreamingSlots = Boolean(document.querySelector('[data-absolute-raw-slot="true"]'));
 var pageHasStreamingSlots = Boolean(document.querySelector('[data-absolute-slot="true"]'));
-var propProviders = Object.entries(pageProps).map(function(entry) {
-    var propName = entry[0];
-    var propValue = entry[1];
-    var token = pageModule[toScreamingSnake(propName)];
-    return isInjectionToken(token) ? { provide: token, useValue: propValue } : null;
-}).filter(Boolean);
-// Page-level providers, opt-in via \`export const providers = [...]\` in the
-// page module. Required so DI tokens that the component (or any service it
-// injects) needs are available client-side too \u2014 without these, services
-// that worked in SSR fail with NG0201 after hydration.
-var maybePageProviders = Reflect.get(pageModule, 'providers');
-var pageProviders = Array.isArray(maybePageProviders) ? maybePageProviders : [];
+var contextProviders = [{ provide: REQUEST_CONTEXT, useValue: requestContext }];
+// Page-level providers come from the build-generated providers file
+// (emitted by \`runAngularHandlerScan\` based on the page's
+// \`handleAngularPageRequest({...})\` call). Falls back to the legacy
+// \`export const providers\` on the page module for projects that
+// haven't migrated yet.
+var legacyPageProviders = Reflect.get(pageModule, 'providers');
+var pageProviders = Array.isArray(generatedProviders)
+    ? generatedProviders
+    : (Array.isArray(legacyPageProviders) ? legacyPageProviders : []);
 var absoluteHttpTransferCacheOptions = {
     includePostRequests: false,
     includeRequestsWithAuthHeaders: false,
@@ -4613,7 +4602,7 @@ if (!window.__HMR_SKIP_HYDRATION__ && !pageHasIslands) {
 }
 delete window.__HMR_SKIP_HYDRATION__;
 providers.push.apply(providers, pageProviders);
-providers.push.apply(providers, propProviders);
+providers.push.apply(providers, contextProviders);
 window.__ABS_SLOT_HYDRATION_PENDING__ = pageHasRawStreamingSlots;
 
 if (pageHasRawStreamingSlots) {
@@ -4641,32 +4630,31 @@ import '@angular/compiler';
 import { bootstrapApplication } from '@angular/platform-browser';
 import { provideClientHydration } from '@angular/platform-browser';
 import { withHttpTransferCacheOptions } from '@angular/platform-browser';
-import { enableProdMode, provideZonelessChangeDetection } from '@angular/core';
+import { enableProdMode, provideZonelessChangeDetection, REQUEST_CONTEXT } from '@angular/core';
 import * as pageModule from '${normalizedImportPath}';
+${generatedProvidersImport}
 
 var ${componentClassName} = pageModule.default;
-var toScreamingSnake = function(str) {
-    return str.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase();
-};
-var isInjectionToken = function(value) {
-    return Boolean(value) && typeof value === 'object' && value.ngMetadataName === 'InjectionToken';
-};
-var pageProps = window.__ABS_ANGULAR_PAGE_PROPS__ || {};
+// REQUEST_CONTEXT is hydrated from the SSR-serialized payload so client-side
+// \`inject(REQUEST_CONTEXT)\` (or \`usePageContext<T>()\`) returns the same
+// object the server rendered with \u2014 no second round-trip, no transferState
+// dance for callers.
+var requestContext = Object.prototype.hasOwnProperty.call(window, '__ABS_ANGULAR_REQUEST_CONTEXT__')
+    ? window.__ABS_ANGULAR_REQUEST_CONTEXT__
+    : null;
 var pageHasIslands = Boolean(pageModule.__ABSOLUTE_PAGE_HAS_ISLANDS__) || Boolean(document.querySelector('[data-island="true"]'));
 var pageHasRawStreamingSlots = Boolean(document.querySelector('[data-absolute-raw-slot="true"]'));
 var pageHasStreamingSlots = Boolean(document.querySelector('[data-absolute-slot="true"]'));
-var propProviders = Object.entries(pageProps).map(function(entry) {
-    var propName = entry[0];
-    var propValue = entry[1];
-    var token = pageModule[toScreamingSnake(propName)];
-    return isInjectionToken(token) ? { provide: token, useValue: propValue } : null;
-}).filter(Boolean);
-// Page-level providers, opt-in via \`export const providers = [...]\` in the
-// page module. Required so DI tokens that the component (or any service it
-// injects) needs are available client-side too \u2014 without these, services
-// that worked in SSR fail with NG0201 after hydration.
-var maybePageProviders = Reflect.get(pageModule, 'providers');
-var pageProviders = Array.isArray(maybePageProviders) ? maybePageProviders : [];
+var contextProviders = [{ provide: REQUEST_CONTEXT, useValue: requestContext }];
+// Page-level providers come from the build-generated providers file
+// (emitted by \`runAngularHandlerScan\` based on the page's
+// \`handleAngularPageRequest({...})\` call). Falls back to the legacy
+// \`export const providers\` on the page module for projects that
+// haven't migrated yet.
+var legacyPageProviders = Reflect.get(pageModule, 'providers');
+var pageProviders = Array.isArray(generatedProviders)
+    ? generatedProviders
+    : (Array.isArray(legacyPageProviders) ? legacyPageProviders : []);
 var absoluteHttpTransferCacheOptions = {
     includePostRequests: false,
     includeRequestsWithAuthHeaders: false,
@@ -4677,7 +4665,7 @@ var absoluteHttpTransferCacheOptions = {
 
 enableProdMode();
 
-var providers = [provideZonelessChangeDetection()].concat(pageProviders).concat(propProviders);
+var providers = [provideZonelessChangeDetection()].concat(pageProviders).concat(contextProviders);
 if (!pageHasIslands) {
     providers.unshift(provideClientHydration(withHttpTransferCacheOptions(absoluteHttpTransferCacheOptions)));
 }
@@ -4735,7 +4723,7 @@ var init_compileAngular = __esm(() => {
   init_stylePreprocessor();
   init_generatedDir();
   devClientDir = resolveDevClientDir();
-  hmrClientPath = join7(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath = join8(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
   jitContentCache = new Map;
   wrapperOutputCache = new Map;
 });
@@ -13846,7 +13834,7 @@ init_constants();
 import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
 import { mkdir as mkdir3, symlink } from "fs/promises";
 import { tmpdir } from "os";
-import { basename as basename4, dirname as dirname5, join as join8, resolve as resolve7 } from "path";
+import { basename as basename4, dirname as dirname5, join as join9, resolve as resolve7 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/core/islandPageContext.ts
@@ -14683,6 +14671,38 @@ var runWithStreamingSlotWarningScope = (task, metadata) => ensureWarningStorage(
 
 // src/angular/pageHandler.ts
 init_ssrRender();
+
+// src/angular/loadRouteMounts.ts
+init_generatedDir();
+import { existsSync as existsSync4 } from "fs";
+import { join as join7 } from "path";
+var cached = null;
+var loadAngularRouteMounts = async () => {
+  if (cached)
+    return cached;
+  const filePath = join7(getFrameworkGeneratedDir("angular", process.cwd()), "route-mounts.ts");
+  if (!existsSync4(filePath)) {
+    cached = [];
+    return cached;
+  }
+  try {
+    const mod = await import(filePath);
+    cached = mod.routeMounts ?? [];
+  } catch (error) {
+    console.warn("[absolute/angular] failed to load route-mounts:", error);
+    cached = [];
+  }
+  return cached;
+};
+var matchAngularBasePath = (mounts, urlPath) => {
+  for (const mount of mounts) {
+    if (mount.pattern.test(urlPath))
+      return mount.basePath;
+  }
+  return "/";
+};
+
+// src/angular/pageHandler.ts
 var lastSelector = "angular-page";
 var isRecord5 = (value) => typeof value === "object" && value !== null;
 var isAngularComponent2 = (value) => typeof value === "function";
@@ -14703,11 +14723,11 @@ var ensureAngularCompiler = () => {
   return compilerImportPromise;
 };
 var readAngularPageModule = (value) => isRecord5(value) ? value : null;
-var resolveAngularSsrOutDir = () => process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR ?? join8(tmpdir(), "absolutejs", "generated", "angular-ssr");
+var resolveAngularSsrOutDir = () => process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR ?? join9(tmpdir(), "absolutejs", "generated", "angular-ssr");
 var createAngularRuntimeCacheBuster = () => `${Date.now().toString(BASE_36_RADIX)}.${Math.random().toString(BASE_36_RADIX).substring(2, RANDOM_ID_END_INDEX)}`;
 var ensureAngularSsrNodeModules = async (outDir) => {
   const outRoot = resolve7(dirname5(dirname5(outDir)));
-  const nodeModulesLink = join8(outRoot, "node_modules");
+  const nodeModulesLink = join9(outRoot, "node_modules");
   if (process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR) {
     return;
   }
@@ -14782,11 +14802,6 @@ var resolveRequestRenderUrl = (request) => {
     return "/";
   }
 };
-var assertNoHandlerProviders = (input) => {
-  if (!("providers" in input))
-    return;
-  throw new Error("Angular handler providers are not supported. Export `providers` from the Angular page module, or inject REQUEST / REQUEST_CONTEXT for request-scoped data.");
-};
 var angularSsrContext = new AsyncLocalStorage3;
 setSsrContextGetter(() => angularSsrContext.getStore());
 var handleAngularPageRequest = async (input) => {
@@ -14797,15 +14812,14 @@ var handleAngularPageRequest = async (input) => {
     const resolvedIndexPath = input.indexPath;
     const options = input;
     const resolvedPagePath = input.pagePath;
-    const maybeProps = input.props;
+    const maybeRequestContext = input.requestContext;
     const responseInit = input.responseInit ?? {};
     const resolvedUrl = resolveRequestRenderUrl(input.request);
     cacheRouteData(resolvedPagePath, {
       headTag: resolvedHeadTag,
-      props: maybeProps
+      requestContext: maybeRequestContext
     });
     try {
-      assertNoHandlerProviders(input);
       const handlerCallsite = options?.collectStreamingSlots === true ? undefined : getCurrentRouteRegistrationCallsite() ?? captureStreamingSlotWarningCallsite();
       const renderPageResponse = async () => {
         const baseDeps = await getAngularDeps();
@@ -14822,24 +14836,35 @@ var handleAngularPageRequest = async (input) => {
         const hasIslands = typeof pageModule.__ABSOLUTE_PAGE_HAS_ISLANDS__ === "boolean" ? pageModule.__ABSOLUTE_PAGE_HAS_ISLANDS__ : false;
         const usesLegacyAnimations = pageModule.__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ === true;
         const deps = baseDeps;
-        const tokenMap = discoverTokens(pageModule);
         const selector = resolveSelector(deps, resolvedPagePath, PageComponent);
         lastSelector = selector;
         const htmlString = `<!DOCTYPE html><html>${resolvedHeadTag}<body><${selector}></${selector}></body></html>`;
         resetSsrSanitizer();
         const sanitizer = getSsrSanitizer(deps);
-        const pageProvidersExport = Reflect.get(pageModule, "providers");
-        const pageProviders = Array.isArray(pageProvidersExport) ? pageProvidersExport : [];
+        const handlerProviders = Array.isArray(input.providers) ? input.providers : [];
+        const legacyProvidersExport = Reflect.get(pageModule, "providers");
+        const legacyPageProviders = handlerProviders.length > 0 ? [] : Array.isArray(legacyProvidersExport) ? legacyProvidersExport : [];
+        const routeMounts = await loadAngularRouteMounts();
+        const requestUrlPath = input.request ? new URL(input.request.url).pathname : "/";
+        const inferredBasePath = matchAngularBasePath(routeMounts, requestUrlPath);
+        const inferredBasePathProvider = inferredBasePath === "/" ? [] : [
+          {
+            provide: deps.APP_BASE_HREF,
+            useValue: inferredBasePath
+          }
+        ];
         const combinedProviders = [
           ...await buildRouterRedirectProviders(deps, responseInit),
-          ...pageProviders,
+          ...inferredBasePathProvider,
+          ...handlerProviders,
+          ...legacyPageProviders,
           ...await buildServerAnimationProviders(usesLegacyAnimations)
         ];
-        const providers = buildProviders(deps, sanitizer, maybeProps, tokenMap, input.request, input.requestContext, responseInit, combinedProviders);
+        const providers = buildProviders(deps, sanitizer, input.request, maybeRequestContext, responseInit, combinedProviders);
         const rawHtml = await renderAngularApp(deps, PageComponent, providers, htmlString, resolvedUrl);
         const shouldProcessIslands = hasIslands || rawHtml.includes("<absolute-island");
         const htmlWithLoweredIslands = shouldProcessIslands ? await lowerAngularServerIslands(rawHtml) : rawHtml;
-        const html = injectIslandPageContext(injectSsrScripts(htmlWithLoweredIslands, requestId, resolvedIndexPath, maybeProps), { hasIslands: shouldProcessIslands });
+        const html = injectIslandPageContext(injectSsrScripts(htmlWithLoweredIslands, requestId, resolvedIndexPath, maybeRequestContext), { hasIslands: shouldProcessIslands });
         return new Response(html, withHtmlContentType(responseInit));
       };
       return await runWithStreamingSlotWarningScope(() => options?.collectStreamingSlots === true ? withRegisteredStreamingSlots(renderPageResponse, options) : renderPageResponse(), { handlerCallsite });
@@ -14856,10 +14881,13 @@ var handleAngularPageRequest = async (input) => {
     }
   });
 };
+// src/angular/composables/usePageContext.ts
+import { inject, REQUEST_CONTEXT } from "@angular/core";
+var usePageContext = () => inject(REQUEST_CONTEXT);
 // src/angular/composables/useResource.ts
-import { DestroyRef, inject, signal } from "@angular/core";
+import { DestroyRef, inject as inject2, signal } from "@angular/core";
 var useResource = (fetcher, options = {}) => {
-  const destroyRef = inject(DestroyRef);
+  const destroyRef = inject2(DestroyRef);
   const start = options.start ?? "immediate";
   const data = signal(null);
   const error = signal(null);
@@ -14917,16 +14945,16 @@ var useResource = (fetcher, options = {}) => {
   return { cancel, data, error, loading, mutate, refresh };
 };
 // src/angular/composables/useSubscription.ts
-import { DestroyRef as DestroyRef2, inject as inject2 } from "@angular/core";
+import { DestroyRef as DestroyRef2, inject as inject3 } from "@angular/core";
 import { takeUntilDestroyed } from "@angular/core/rxjs-interop";
 function useSubscription(observable, observerOrNext) {
-  const destroyRef = inject2(DestroyRef2);
+  const destroyRef = inject3(DestroyRef2);
   return observable.pipe(takeUntilDestroyed(destroyRef)).subscribe(typeof observerOrNext === "function" ? { next: observerOrNext } : observerOrNext);
 }
 // src/angular/composables/useTimers.ts
-import { DestroyRef as DestroyRef3, inject as inject3 } from "@angular/core";
+import { DestroyRef as DestroyRef3, inject as inject4 } from "@angular/core";
 var useTimers = () => {
-  const destroyRef = inject3(DestroyRef3);
+  const destroyRef = inject4(DestroyRef3);
   const timeouts = new Set;
   const intervals = new Set;
   const clearAll = () => {
@@ -14966,7 +14994,7 @@ var useTimers = () => {
   };
 };
 // src/angular/preserveAcrossHmr.ts
-import { ChangeDetectorRef, inject as inject4 } from "@angular/core";
+import { ChangeDetectorRef, inject as inject5 } from "@angular/core";
 
 // src/angular/hmrPreserveCore.ts
 var isHmrPreserveDev = () => {
@@ -15037,15 +15065,15 @@ var preserveAcrossHmr = (instance, key) => {
   if (!restored)
     return;
   try {
-    const cdr = inject4(ChangeDetectorRef, { optional: true });
+    const cdr = inject5(ChangeDetectorRef, { optional: true });
     if (cdr)
       queueMicrotask(() => cdr.markForCheck());
   } catch {}
 };
 // src/angular/pendingTask.ts
-import { inject as inject5, PendingTasks } from "@angular/core";
+import { inject as inject6, PendingTasks } from "@angular/core";
 var withPendingTask = async (work) => {
-  const removeTask = inject5(PendingTasks).add();
+  const removeTask = inject6(PendingTasks).add();
   try {
     return await work();
   } finally {
@@ -15245,7 +15273,7 @@ import {
   ChangeDetectorRef as ChangeDetectorRef2,
   Component as Component2,
   Input as Input2,
-  inject as inject6,
+  inject as inject7,
   signal as signal2
 } from "@angular/core";
 import { DomSanitizer } from "@angular/platform-browser";
@@ -15262,8 +15290,8 @@ class StreamSlotComponent {
   constructor() {
     this.fallbackHtml = "";
   }
-  cdr = inject6(ChangeDetectorRef2);
-  sanitizer = inject6(DomSanitizer);
+  cdr = inject7(ChangeDetectorRef2);
+  sanitizer = inject7(DomSanitizer);
   slotConsumer = (payload) => {
     this.currentHtml.set(this.sanitizer.bypassSecurityTrustHtml(resolvePayloadHtml(payload)));
     this.cdr.markForCheck();
@@ -15351,6 +15379,7 @@ export {
   useTimers,
   useSubscription,
   useResource,
+  usePageContext,
   renderIsland,
   provideDeterministicEnv,
   preserveAcrossHmr,
@@ -15368,5 +15397,5 @@ export {
   ABSOLUTE_HTTP_TRANSFER_CACHE_SKIP_HEADER
 };
 
-//# debugId=D0855BF600604B6564756E2164756E21
+//# debugId=611222AD0534104464756E2164756E21
 //# sourceMappingURL=index.js.map