@absolutejs/absolute 0.19.0-beta.1043 → 0.19.0-beta.1045

package/dist/src/angular/components/defer-slot.component.d.ts

@@ -0,0 +1,29 @@
+import { type AfterViewInit } from '@angular/core';
+import { type AngularDeferSlotPayload } from './defer-slot-payload.js';
+import { type DeferSlotTemplateContext, DeferErrorTemplateDirective, DeferFallbackTemplateDirective, DeferResolvedTemplateDirective } from './defer-slot-templates.directive.js';
+import * as i0 from "@angular/core";
+type DeferSlotResolver = () => Promise<AngularDeferSlotPayload>;
+type DeferSlotState = 'error' | 'fallback' | 'resolved';
+export declare class DeferSlotComponent implements AfterViewInit {
+    private readonly cdr;
+    private readonly runtimeReady;
+    private serverSlotRegistered;
+    className?: string;
+    id: string;
+    resolve?: DeferSlotResolver;
+    resolvedTemplate?: DeferResolvedTemplateDirective;
+    fallbackTemplate?: DeferFallbackTemplateDirective;
+    errorTemplate?: DeferErrorTemplateDirective;
+    readonly slotData: import("@angular/core").WritableSignal<Record<string, string>>;
+    readonly state: import("@angular/core").WritableSignal<DeferSlotState>;
+    readonly activeTemplate: () => import("@angular/core").TemplateRef<unknown> | null;
+    readonly templateContext: () => DeferSlotTemplateContext;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private registerServerSlot;
+    private applyPatchPayload;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeferSlotComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DeferSlotComponent, "abs-defer-slot", never, { "className": { "alias": "className"; "required": false; }; "id": { "alias": "id"; "required": false; }; "resolve": { "alias": "resolve"; "required": false; }; }, {}, ["resolvedTemplate", "fallbackTemplate", "errorTemplate"], never, true, never>;
+}
+export {};

package/dist/src/angular/components/image.component.d.ts

@@ -0,0 +1,42 @@
+import * as i0 from "@angular/core";
+export declare class ImageComponent {
+    readonly alt: import("@angular/core").InputSignal<string>;
+    readonly blurDataURL: import("@angular/core").InputSignal<string | undefined>;
+    readonly className: import("@angular/core").InputSignal<string | undefined>;
+    readonly crossOrigin: import("@angular/core").InputSignal<"" | "anonymous" | "use-credentials" | undefined>;
+    readonly fetchPriority: import("@angular/core").InputSignal<"high" | "low" | "auto" | undefined>;
+    readonly fill: import("@angular/core").InputSignal<boolean>;
+    readonly height: import("@angular/core").InputSignal<number | undefined>;
+    readonly loader: import("@angular/core").InputSignal<((params: {
+        src: string;
+        width: number;
+        quality: number;
+    }) => string) | undefined>;
+    readonly loading: import("@angular/core").InputSignal<"lazy" | "eager">;
+    readonly onError: import("@angular/core").InputSignal<((event: Event) => void) | undefined>;
+    readonly onLoad: import("@angular/core").InputSignal<((event: Event) => void) | undefined>;
+    readonly overrideSrc: import("@angular/core").InputSignal<string | undefined>;
+    readonly placeholder: import("@angular/core").InputSignal<string>;
+    readonly priority: import("@angular/core").InputSignal<boolean>;
+    readonly quality: import("@angular/core").InputSignal<number>;
+    readonly referrerPolicy: import("@angular/core").InputSignal<string | undefined>;
+    readonly sizes: import("@angular/core").InputSignal<string | undefined>;
+    readonly src: import("@angular/core").InputSignal<string>;
+    readonly style: import("@angular/core").InputSignal<Record<string, string | number> | undefined>;
+    readonly unoptimized: import("@angular/core").InputSignal<boolean>;
+    readonly width: import("@angular/core").InputSignal<number | undefined>;
+    private readonly blurRemoved;
+    readonly resolvedSrc: import("@angular/core").Signal<string>;
+    readonly srcSet: import("@angular/core").Signal<any>;
+    readonly resolvedSrcSet: import("@angular/core").Signal<any>;
+    readonly resolvedSizes: import("@angular/core").Signal<string | null>;
+    readonly resolvedCrossOrigin: import("@angular/core").Signal<"" | "anonymous" | "use-credentials" | null>;
+    readonly resolvedReferrerPolicy: import("@angular/core").Signal<string | null>;
+    readonly resolvedLoading: import("@angular/core").Signal<"lazy" | "eager">;
+    readonly resolvedFetchPriority: import("@angular/core").Signal<"high" | "low" | "auto" | null>;
+    readonly imgStyle: import("@angular/core").Signal<Record<string, string | number>>;
+    handleLoad(event: Event): void;
+    handleError(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageComponent, "abs-image", never, { "alt": { "alias": "alt"; "required": true; "isSignal": true; }; "blurDataURL": { "alias": "blurDataURL"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "crossOrigin": { "alias": "crossOrigin"; "required": false; "isSignal": true; }; "fetchPriority": { "alias": "fetchPriority"; "required": false; "isSignal": true; }; "fill": { "alias": "fill"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "loader": { "alias": "loader"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "onError": { "alias": "onError"; "required": false; "isSignal": true; }; "onLoad": { "alias": "onLoad"; "required": false; "isSignal": true; }; "overrideSrc": { "alias": "overrideSrc"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "priority": { "alias": "priority"; "required": false; "isSignal": true; }; "quality": { "alias": "quality"; "required": false; "isSignal": true; }; "referrerPolicy": { "alias": "referrerPolicy"; "required": false; "isSignal": true; }; "sizes": { "alias": "sizes"; "required": false; "isSignal": true; }; "src": { "alias": "src"; "required": true; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "unoptimized": { "alias": "unoptimized"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/dist/src/angular/components/index.d.ts

@@ -0,0 +1,4 @@
+export { DeferSlotComponent } from './defer-slot.component.js';
+export { DeferErrorTemplateDirective, DeferFallbackTemplateDirective, DeferResolvedTemplateDirective } from './defer-slot-templates.directive.js';
+export { ImageComponent } from './image.component.js';
+export { StreamSlotComponent } from './stream-slot.component.js';

package/dist/src/angular/components/stream-slot.component.d.ts

@@ -0,0 +1,20 @@
+import { type SafeHtml } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+type SlotResolver = () => Promise<string> | string;
+export declare class StreamSlotComponent {
+    private readonly cdr;
+    private readonly sanitizer;
+    private readonly slotConsumer;
+    className?: string;
+    errorHtml?: string;
+    fallbackHtml: string;
+    id: string;
+    resolve: SlotResolver;
+    timeoutMs?: number;
+    readonly currentHtml: import("@angular/core").WritableSignal<string | SafeHtml>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StreamSlotComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StreamSlotComponent, "abs-stream-slot", never, { "className": { "alias": "className"; "required": false; }; "errorHtml": { "alias": "errorHtml"; "required": false; }; "fallbackHtml": { "alias": "fallbackHtml"; "required": false; }; "id": { "alias": "id"; "required": true; }; "resolve": { "alias": "resolve"; "required": true; }; "timeoutMs": { "alias": "timeoutMs"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/dist/src/angular/composables/index.d.ts

@@ -0,0 +1,6 @@
+export { usePageContext } from './usePageContext';
+export { useResource } from './useResource';
+export type { Resource, ResourceFetcher, ResourceMutator, ResourceOptions, ResourceStart } from './useResource';
+export { useSubscription } from './useSubscription';
+export type { Observer } from './useSubscription';
+export { useTimers } from './useTimers';

package/dist/src/angular/composables/usePageContext.d.ts

@@ -0,0 +1,16 @@
+/** Typed accessor for the per-request context object the backend handler
+ *  passed via `requestContext`. AbsoluteJS provides it through Angular's
+ *  standard `REQUEST_CONTEXT` token on both SSR and client hydration, so
+ *  the value is identical across both phases.
+ *
+ *  `REQUEST_CONTEXT`'s value type is `unknown` upstream, which is correct
+ *  for a token that can carry anything. Pages know the shape they expect,
+ *  so this composable takes a generic parameter the caller fills in.
+ *  Type-safety is enforced at the call site in the backend handler
+ *  (`handleAngularPageRequest<Ctx>({ requestContext: Ctx })`) — the
+ *  generic on both sides has to agree for the program to compile, so
+ *  the cast inside this composable can't go out of sync with reality.
+ *
+ *  Must be called in an Angular injection context (component
+ *  constructor, field initializer, or `runInInjectionContext`). */
+export declare const usePageContext: <T>() => T;

package/dist/src/angular/composables/useResource.d.ts

@@ -0,0 +1,57 @@
+import { type Signal } from '@angular/core';
+export type ResourceFetcher<T> = (signal: AbortSignal) => Promise<T>;
+/** Controls the resource's startup behavior.
+ *
+ *  - `'immediate'` (default) — fire the fetcher synchronously at creation;
+ *    `loading()` starts `true`.
+ *  - `'pending'` — don't fire the fetcher yet, but render as if a fetch is
+ *    coming: `loading()` starts `true`. Pair with a manual `refresh()` call
+ *    from `ngOnInit` (or wherever the dependencies become available). Use
+ *    this when the fetcher depends on state set after construction (e.g. a
+ *    route param assigned by the page factory) — it avoids the blank-frame
+ *    flash you'd get from `'idle'`.
+ *  - `'idle'` — don't fire the fetcher and don't pretend you will:
+ *    `loading()` starts `false`. The resource is dormant until `refresh()`
+ *    or `mutate()` is called.
+ */
+export type ResourceStart = 'immediate' | 'pending' | 'idle';
+export type ResourceOptions = {
+    /** When and how the fetcher fires on creation. Default: `'immediate'`. */
+    start?: ResourceStart;
+};
+export type ResourceMutator<T> = T | null | ((prev: T | null) => T | null);
+export type Resource<T> = {
+    /** Latest resolved value, or `null` before the first successful load. */
+    data: Signal<T | null>;
+    /** Latest rejection reason, or `null` when the resource is healthy. */
+    error: Signal<unknown>;
+    /** True while a fetch is in flight, or when `start: 'pending'` was set
+     *  and `refresh()` hasn't been called yet. */
+    loading: Signal<boolean>;
+    /** Re-runs the fetcher. Any in-flight request is aborted first. */
+    refresh: () => Promise<void>;
+    /** Aborts the in-flight request, if any. No-op otherwise. */
+    cancel: () => void;
+    /** Imperatively write the data signal without re-fetching. Accepts a
+     *  new value or an updater function. Use after an edit action returns
+     *  the new entity, so you avoid a wasteful re-fetch. Pending fetches
+     *  are aborted so a slower response can't clobber the mutation. */
+    mutate: (next: ResourceMutator<T>) => void;
+};
+/** Signal-backed async data composable. Replaces the React
+ *  `useEffect(() => { fetch(); }, [])` + `useState` pair with a single
+ *  call that's safe in zoneless Angular (the signals it returns trigger
+ *  change detection automatically when consumed in a template).
+ *
+ *  ```ts
+ *  const profile = useResource(() => api.profile.me.get());
+ *
+ *  // in template:
+ *  // @if (profile.loading()) { … }
+ *  // @if (profile.data(); as data) { {{ data.name }} }
+ *  ```
+ *
+ *  The fetcher receives an `AbortSignal` it can pass to `fetch` — the
+ *  signal aborts on component destroy or on a new `refresh()` call.
+ *  Must be called in an injection context. */
+export declare const useResource: <T>(fetcher: ResourceFetcher<T>, options?: ResourceOptions) => Resource<T>;

package/dist/src/angular/composables/useSubscription.d.ts

@@ -0,0 +1,33 @@
+import { DestroyRef } from '@angular/core';
+import type { Observable, Subscription } from 'rxjs';
+export type Observer<T> = {
+    next?: (value: T) => void;
+    error?: (err: unknown) => void;
+    complete?: () => void;
+};
+/** Subscribe to an Observable with automatic teardown when the host
+ *  component is destroyed. Equivalent to
+ *  `observable.pipe(takeUntilDestroyed(destroyRef)).subscribe(observer)`,
+ *  collapsed into one call so consumers can't forget the cleanup
+ *  operator (the most common Angular memory-leak source).
+ *
+ *  `inject(DestroyRef)` is only legal in an Angular injection context
+ *  (constructor, field initializer, factory,
+ *  `runInInjectionContext`). Calling `useSubscription` without a
+ *  captured `DestroyRef` from `ngOnInit` or any other lifecycle hook
+ *  will throw `NG0203`. For those call sites, capture the ref once in
+ *  a field initializer (`private destroyRef = inject(DestroyRef);`)
+ *  and pass it as the third argument:
+ *
+ *  ```ts
+ *  ngOnInit() {
+ *    useSubscription(this.events$, (event) => { ... }, this.destroyRef);
+ *  }
+ *  ```
+ *
+ *  Note: this composable handles teardown only — it does not trigger
+ *  change detection on emissions. If the observer mutates state that
+ *  drives the template, store that state in a `signal()` so updates
+ *  propagate in zoneless Angular. */
+export declare function useSubscription<T>(observable: Observable<T>, next: (value: T) => void, destroyRef?: DestroyRef): Subscription;
+export declare function useSubscription<T>(observable: Observable<T>, observer: Observer<T>, destroyRef?: DestroyRef): Subscription;

package/dist/src/angular/composables/useTimers.d.ts

@@ -0,0 +1,18 @@
+/** Component-scoped `setTimeout` / `setInterval` with automatic cleanup
+ *  on `DestroyRef.onDestroy`. Use instead of raw `setTimeout` so timers
+ *  scheduled by a component never outlive it.
+ *
+ *  Must be called in an Angular injection context (component constructor,
+ *  field initializer, or `runInInjectionContext`).
+ *
+ *  Note: this composable just manages timers — it does not trigger change
+ *  detection. If the timer callback mutates state that drives the template,
+ *  store that state in a `signal()` so the update propagates in zoneless
+ *  Angular. See the absolutejs docs on zoneless change detection. */
+export declare const useTimers: () => {
+    clearAll: () => void;
+    clearInterval(timer: ReturnType<typeof setInterval> | null | undefined): void;
+    clearTimeout(timer: ReturnType<typeof setTimeout> | null | undefined): void;
+    setInterval(callback: () => void, delayMs: number): NodeJS.Timeout;
+    setTimeout(callback: () => void, delayMs: number): NodeJS.Timeout;
+};

package/dist/src/angular/createIsland.browser.d.ts

@@ -0,0 +1,2 @@
+import type { IslandRegistry, IslandRegistryInput, TypedIslandRenderProps } from '../../types/island';
+export declare const createTypedIsland: <T extends IslandRegistryInput>(_registry: IslandRegistry<T>) => (props: TypedIslandRenderProps<T>) => string;

package/dist/src/angular/createIsland.d.ts

@@ -0,0 +1,2 @@
+import type { IslandRegistry, IslandRegistryInput, TypedIslandRenderProps } from '../../types/island';
+export declare const createTypedIsland: <T extends IslandRegistryInput>(registry: IslandRegistry<T>) => (props: TypedIslandRenderProps<T>) => Promise<string>;

package/dist/src/angular/deterministicEnv.d.ts

@@ -0,0 +1,26 @@
+import { InjectionToken } from '@angular/core';
+export type DeterministicRandom = () => number;
+export type DeterministicEnvOptions = {
+    now?: Date | number | string;
+    seed?: number | string;
+};
+export declare const DETERMINISTIC_NOW: InjectionToken<number>;
+export declare const DETERMINISTIC_RANDOM: InjectionToken<DeterministicRandom>;
+export declare const DETERMINISTIC_SEED: InjectionToken<string>;
+export declare const createDeterministicRandom: (seed?: number | string) => () => number;
+export declare const provideDeterministicEnv: (options?: DeterministicEnvOptions) => ({
+    provide: InjectionToken<string>;
+    useValue: string;
+    deps?: undefined;
+    useFactory?: undefined;
+} | {
+    provide: InjectionToken<number>;
+    useValue: number;
+    deps?: undefined;
+    useFactory?: undefined;
+} | {
+    deps: InjectionToken<string>[];
+    provide: InjectionToken<DeterministicRandom>;
+    useFactory: (seed?: number | string) => () => number;
+    useValue?: undefined;
+})[];

package/dist/src/angular/hmrPreserveCore.d.ts

@@ -0,0 +1,21 @@
+export type StateCache = Map<string, Record<string, unknown>>;
+export type InstanceTracker = Set<WeakRef<object>>;
+export type InstanceKeyMap = WeakMap<object, string>;
+export type RebootFlag = {
+    value: boolean;
+};
+export type RebootStats = {
+    captured: number;
+    restoredKeys: Set<string>;
+};
+export declare const buildCacheKey: (instance: object, key?: unknown) => string | null;
+export declare const captureTrackedInstanceStates: () => void;
+export declare const endHmrReboot: () => void;
+export declare const getCache: () => Map<any, any>;
+export declare const getKeyMap: () => InstanceKeyMap;
+export declare const getRebootFlag: () => RebootFlag;
+export declare const getRebootStats: () => RebootStats;
+export declare const getTracker: () => InstanceTracker;
+export declare const isHmrPreserveDev: () => boolean;
+export declare const isPreservable: (value: unknown, depth?: number) => boolean;
+export declare const restoreFromCacheCore: (instance: object, key: string) => boolean;

package/dist/src/angular/httpTransferCache.d.ts

@@ -0,0 +1,12 @@
+import type { HttpTransferCacheOptions } from '@angular/common/http';
+export declare const ABSOLUTE_HTTP_TRANSFER_CACHE_SKIP_HEADER = "x-skip-transfer-cache";
+export type AbsoluteHttpTransferCacheOptions = Omit<HttpTransferCacheOptions, 'filter'> & {
+    filter?: NonNullable<HttpTransferCacheOptions['filter']>;
+    skipHeader?: string;
+};
+export declare const buildAbsoluteHttpTransferCacheOptions: (options?: AbsoluteHttpTransferCacheOptions) => {
+    filter: (request: import("@angular/common/http").HttpRequest<unknown>) => boolean;
+    includeHeaders?: string[] | undefined;
+    includePostRequests: boolean;
+    includeRequestsWithAuthHeaders: boolean;
+};

package/dist/src/angular/index.d.ts

@@ -0,0 +1,14 @@
+import '@angular/compiler';
+export { ABSOLUTE_HTTP_TRANSFER_CACHE_SKIP_HEADER, buildAbsoluteHttpTransferCacheOptions } from './httpTransferCache';
+export { createDeterministicRandom, DETERMINISTIC_NOW, DETERMINISTIC_RANDOM, DETERMINISTIC_SEED, provideDeterministicEnv } from './deterministicEnv';
+export { handleAngularPageRequest } from './pageHandler';
+export { usePageContext, useResource, useSubscription, useTimers } from './composables';
+export type { Observer, Resource, ResourceFetcher, ResourceMutator, ResourceOptions, ResourceStart } from './composables';
+export { preserveAcrossHmr } from './preserveAcrossHmr';
+export { withPendingTask } from './pendingTask';
+export { createTypedIsland } from './createIsland';
+export { getCachedRouteData } from './ssrRender';
+export { Island } from './Island';
+export { IslandStore } from './islandStore';
+export { renderIsland } from './renderIsland';
+export { StreamSlotComponent } from './components/stream-slot.component';

package/dist/src/angular/injectorPatch.d.ts

@@ -0,0 +1 @@
+export declare const patchAngularCompilerFacade: () => void;

package/dist/src/angular/islandStore.d.ts

@@ -0,0 +1,9 @@
+import { Observable } from 'rxjs';
+import type { StoreApi } from 'zustand/vanilla';
+import { type IslandStoreState } from '../client/islandStore';
+declare class IslandStoreImpl {
+    get<TState extends IslandStoreState, TSelected>(store: StoreApi<TState>, selector: (state: TState) => TSelected): TSelected;
+    select<TState extends IslandStoreState, TSelected>(store: StoreApi<TState>, selector: (state: TState) => TSelected): Observable<TSelected>;
+}
+export declare const IslandStore: typeof IslandStoreImpl;
+export {};

package/dist/src/angular/islands.d.ts

@@ -0,0 +1,4 @@
+export declare const getAngularIslandSelector: (_islandId: string) => string;
+export declare const isAngularComponent: (value: unknown) => value is import("@angular/core").Type<object>;
+export declare const mountAngularIsland: <Props extends Record<string, unknown>>(component: import("@angular/core").Type<object>, element: HTMLElement, props: Props, islandId: string) => Promise<import("@angular/core").ApplicationRef>;
+export declare const renderAngularIslandToHtml: <Props extends Record<string, unknown>>(component: import("@angular/core").Type<object>, props: Props, islandId: string) => Promise<string>;

package/dist/src/angular/lowerDeferSyntax.d.ts

@@ -0,0 +1,18 @@
+export type LoweredAngularDeferSlot = {
+    delayMs: number;
+    errorHtml: string | null;
+    fallbackHtml: string;
+    id: string;
+    resolvedBindings: Array<{
+        expression: string;
+        key: string;
+    }>;
+    resolvedHtml: string;
+    resolvedTemplate: string;
+};
+export type LoweredAngularDeferResult = {
+    slots: LoweredAngularDeferSlot[];
+    template: string;
+    transformed: boolean;
+};
+export declare const lowerAngularDeferSyntax: (template: string) => LoweredAngularDeferResult;

package/dist/src/angular/lowerServerIslands.d.ts

@@ -0,0 +1 @@
+export declare const lowerAngularServerIslands: (html: string) => Promise<string>;

package/dist/src/angular/pageHandler.d.ts

@@ -0,0 +1,48 @@
+import type { EnvironmentProviders, Provider } from '@angular/core';
+import { type StreamingSlotEnhancerOptions } from '../core/responseEnhancers';
+type AngularPageRenderOptions = StreamingSlotEnhancerOptions & {
+    collectStreamingSlots?: boolean;
+};
+/** True when the request-context type has no required keys — used to
+ *  flip the `requestContext` argument between required and optional.
+ *  Pages whose `Context` has only optional fields (or where the caller
+ *  passes no generic at all) can omit `requestContext`. */
+type HasNoRequiredContextKeys<Ctx> = keyof Ctx extends never ? true : Partial<Ctx> extends Ctx ? true : false;
+export type AngularPageRequestInput<Ctx = unknown> = AngularPageRenderOptions & {
+    headTag?: `<head>${string}</head>`;
+    indexPath: string;
+    pagePath: string;
+    /** The incoming request. When provided, its URL is forwarded to
+     *  Angular's `renderApplication`, so `LocationStrategy.path()` and
+     *  Angular Router both see the real URL instead of `/`. Without it,
+     *  Router-based pages can't match anything but the root route. */
+    request?: Request;
+    /** Mutable response init made available through Angular's RESPONSE_INIT token. */
+    responseInit?: ResponseInit;
+    /** Extra per-request providers merged in on top of the page
+     *  module's bundled providers (`appProviders` + `provideRouter` +
+     *  `APP_BASE_HREF`) at SSR bootstrap. Use for handler-scoped DI
+     *  values that depend on the request — e.g. a tenant-specific
+     *  feature-flag service, a per-request HTTP interceptor token,
+     *  or test-only overrides. The same Angular module instance is
+     *  shared (the backend resolves `@angular/core` through the same
+     *  `node_modules` Bun cache key as the rebuilt page bundle), so
+     *  tokens declared here interop with the bundled providers.
+     *
+     *  **SSR-only.** The browser bundle doesn't see these — the
+     *  client picks up only the providers baked into the page
+     *  module. If the same provider must run on both sides, add it
+     *  to `absolute.config.ts > angular.providers` instead. */
+    providers?: ReadonlyArray<Provider | EnvironmentProviders>;
+    /** Sitemap metadata for this route. Statically read from the handler
+     *  source at registration time, so only literal-object values are
+     *  honoured. For finer control use `Route.data.sitemap` in the
+     *  page's `Routes` config, or `sitemap.overrides` in `absolute.config.ts`. */
+    sitemap?: import('../../types/sitemap').PageHandlerSitemapMetadata;
+} & (HasNoRequiredContextKeys<Ctx> extends true ? {
+    requestContext?: NoInfer<Ctx>;
+} : {
+    requestContext: NoInfer<Ctx>;
+});
+export declare const handleAngularPageRequest: <Page = unknown>(input: AngularPageRequestInput<Page>) => Promise<Response>;
+export {};

package/dist/src/angular/pendingTask.d.ts

@@ -0,0 +1 @@
+export declare const withPendingTask: <Value>(work: () => Promise<Value>) => Promise<Value>;

package/dist/src/angular/preserveAcrossHmr.d.ts

@@ -0,0 +1,12 @@
+/** Mark a service or component instance for state preservation across
+ *  full Angular HMR re-bootstraps. Call once from the constructor or
+ *  `ngOnInit`. Safe in production (no-op outside dev mode).
+ *
+ *  @param instance Usually `this`. The class name is used as part of
+ *      the cache key.
+ *  @param key Optional discriminator when multiple instances of the
+ *      same class can be alive at once (rows, tabs, etc). Coerced
+ *      to string. Use `ngOnInit` to call this when the key depends
+ *      on `@Input` values, since Angular sets inputs between
+ *      constructor and ngOnInit. */
+export declare const preserveAcrossHmr: (instance: object, key?: string | number) => void;

package/dist/src/angular/renderIsland.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeIslandRenderProps } from '../../types/island';
+export declare const renderIsland: (props: RuntimeIslandRenderProps) => Promise<string>;

package/dist/src/angular/requestProviders.d.ts

@@ -0,0 +1,5 @@
+import type { AngularDeps } from '../../types/angular';
+export declare const buildRequestProviders: (deps: AngularDeps, request: Request | undefined, requestContext: unknown, responseInit: ResponseInit | undefined) => {
+    provide: import("@angular/core").InjectionToken<unknown>;
+    useValue: {} | null;
+}[];

package/dist/src/angular/resolveAngularPackage.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Resolve Angular package paths from the compiled runtime node_modules first,
+ * then the app's process.cwd()/node_modules, falling back to the bare specifier.
+ * This prevents Bun's baked import.meta.dir from resolving Angular packages
+ * from the absolutejs source tree instead of the consumer's project when
+ * running from a published npm package.
+ */
+export declare const resolveAngularPackageDir: (specifier: string) => string | null;
+export declare const resolveAngularPackage: (specifier: string) => string;
+/** Prefer the linked Bun-target vendor file built by
+ *  `buildAngularServerVendor`. The file is at
+ *  `<ABSOLUTE_BUILD_DIR>/angular/vendor/server/<safe>.js`, which is what every
+ *  server bundle's `@angular/*` imports get rewritten to point at. Sharing
+ *  this path keeps SSR's class identity unified — the dual-package hazard
+ *  that produces NG0201 only appears when the runtime imports a *different*
+ *  copy from the bundles. Falls back to `resolveAngularPackage` (node_modules)
+ *  when no vendor file is available — e.g. running tests outside an
+ *  absolutejs build, or before the vendor pass completes. */
+export declare const resolveAngularRuntimePath: (specifier: string) => string;

package/dist/src/angular/routerRedirectProviders.d.ts

@@ -0,0 +1,6 @@
+import type { AngularDeps } from '../../types/angular';
+export declare const buildRouterRedirectProviders: (deps: AngularDeps, responseInit: ResponseInit | undefined) => Promise<{
+    multi: true;
+    provide: import("@angular/core").InjectionToken<readonly (() => void)[]>;
+    useValue: () => void;
+}[]>;

package/dist/src/angular/server.d.ts

@@ -0,0 +1,4 @@
+export { ABSOLUTE_HTTP_TRANSFER_CACHE_SKIP_HEADER, buildAbsoluteHttpTransferCacheOptions } from './httpTransferCache';
+export { createDeterministicRandom, DETERMINISTIC_NOW, DETERMINISTIC_RANDOM, DETERMINISTIC_SEED, provideDeterministicEnv } from './deterministicEnv';
+export { handleAngularPageRequest } from './pageHandler';
+export { withPendingTask } from './pendingTask';

package/dist/src/angular/ssrRender.d.ts

@@ -0,0 +1,13 @@
+import type { EnvironmentProviders, Provider, Type } from '@angular/core';
+import type { AngularDeps, CachedRouteData } from '../../types/angular';
+export declare const cacheRouteData: (pagePath: string, data: CachedRouteData) => void;
+export declare const getCachedRouteData: (pagePath: string) => CachedRouteData | undefined;
+export declare const buildProviders: (deps: AngularDeps, sanitizer: InstanceType<AngularDeps["DomSanitizer"]>, request: Request | undefined, requestContext: unknown, responseInit: ResponseInit | undefined, userProviders?: ReadonlyArray<Provider | EnvironmentProviders>) => ({
+    provide: import("@angular/core").InjectionToken<unknown>;
+    useValue: {} | null;
+} | Provider | EnvironmentProviders)[];
+export declare const clearSelectorCache: () => void;
+export declare const resolveSelector: (deps: AngularDeps, pagePath: string, PageComponent: Type<unknown>) => string;
+export declare const injectSsrScripts: (html: string, requestId: string, indexPath: string, requestContext?: unknown) => string;
+export declare const renderAngularApp: (deps: AngularDeps, PageComponent: Type<unknown>, providers: (Provider | EnvironmentProviders)[], document: string | Document, url?: string) => Promise<string>;
+export declare const withSuppressedAngularDevLogs: <T>(render: () => Promise<T>) => Promise<T>;

package/dist/src/angular/ssrSanitizer.d.ts

@@ -0,0 +1,3 @@
+import type { AngularDeps } from '../../types/angular';
+export declare const getSsrSanitizer: (deps: AngularDeps) => import("@angular/platform-browser").DomSanitizer;
+export declare const resetSsrSanitizer: () => void;

package/dist/src/angular/staticAnalyzeSpaRoutes.d.ts

@@ -0,0 +1,7 @@
+import type { SpaHost } from '../utils/spaRouteTypes';
+/** Statically scan an Angular page-source directory for SPA hosts —
+ *  files that both import `APP_BASE_HREF`/`provideRouter` and declare
+ *  an `APP_BASE_HREF` provider plus a literal `Routes` array. Returns
+ *  one entry per host with the mount path and leaf routes. Does not
+ *  load or execute user code. */
+export declare const analyzeAngularSpaRoutes: (angularDirectory: string) => Promise<SpaHost[]>;

package/dist/src/build/angularLinkerPlugin.d.ts

@@ -0,0 +1,29 @@
+import type { BunPlugin } from 'bun';
+export declare const ANGULAR_LINKER_CANDIDATE_RE: RegExp;
+/**
+ * Bun bundler plugin that runs the Angular Linker on partially compiled
+ * Angular libraries at build time. Converts ɵɵngDeclare* declarations
+ * into fully linked code.
+ *
+ * The `linkerJitMode` flag controls whether NgModule definitions retain
+ * `declarations`/`exports` (JIT-mode, required when consumer code is
+ * runtime-compiled) or strip them (AOT-mode, smaller output but only
+ * correct when consumer components have ɵcmp.dependencies baked in by
+ * the Angular compiler-cli).
+ *
+ * In AbsoluteJS dev/HMR, user components are TypeScript-transpiled via
+ * `compileAngularFileJIT` and rely on @angular/compiler at runtime —
+ * that runtime JIT path reads `NgModule.ɵmod.declarations` to find
+ * directives like FormGroupDirective. Linking vendor code in AOT mode
+ * (the default) silently breaks dev because declarations get stripped
+ * and runtime JIT then can't resolve `[formGroup]`, `[ngIf]`, etc. So
+ * dev/HMR builds must use `linkerJitMode: true`. Production AOT builds
+ * use `linkerJitMode: false` (matches AOT'd user components).
+ *
+ * Cache key includes mode so dev and prod artifacts don't collide.
+ */
+export declare const createAngularLinkerPlugin: (linkerJitMode: boolean) => BunPlugin;
+/** Default AOT-mode plugin instance — keep for callers that don't need
+ *  to choose. Production AOT builds and any callsite that AOT-compiles
+ *  user components alongside vendor should use this. */
+export declare const angularLinkerPlugin: BunPlugin;

package/dist/src/build/buildAngularVendor.d.ts

@@ -0,0 +1,40 @@
+/** Build vendor bundles for every @angular/* package the project imports.
+ *  `linkerJitMode` controls whether NgModule definitions retain their
+ *  declarations/exports — required when consumer (user) components are
+ *  runtime-compiled by `@angular/compiler` (dev/HMR via compileAngularFileJIT).
+ *  Production AOT builds set this to false to match AOT'd user components.
+ *
+ *  `depVendorSpecifiers` are non-framework packages that are also vendored
+ *  separately (by `buildDepVendor`). They MUST be externalized here too —
+ *  otherwise transitive imports like `@angular/fire/compat/auth` →
+ *  `firebase/compat/auth` get bundled twice, creating duplicate
+ *  @firebase/app-compat instances. The angular-vendor copy registers
+ *  `firebase.auth.*` on its own firebase singleton, leaving the user's
+ *  `import firebase from 'firebase/compat/app'` with `firebase.auth` undefined.
+ *  Externalizing forces both pipelines to share the same /vendor chunks. */
+export declare const buildAngularVendor: (buildDir: string, directories?: string[], linkerJitMode?: boolean, depVendorSpecifiers?: string[]) => Promise<string[]>;
+export declare const computeAngularVendorPaths: (specifiers?: string[]) => Record<string, string>;
+/** Async variant that scans source + transitive deps before producing the
+ *  vendor path map. Use this when the page-bundle build needs the full set of
+ *  angular specs in its rewrite map (otherwise transitively-discovered subpaths
+ *  like `@angular/core/rxjs-interop` end up as bare specifiers in the output). */
+export declare const computeAngularVendorPathsAsync: (directories?: string[], linkerJitMode?: boolean) => Promise<Record<string, string>>;
+/** Server-side counterpart to `buildAngularVendor`. Outputs fully-linked
+ *  Bun-target ESM bundles for every @angular/* package the project uses,
+ *  *plus* `@angular/platform-server` and `@angular/ssr` (excluded from the
+ *  browser vendor). The server bundle and `getAngularDeps()` import from
+ *  these paths so SSR shares one Angular runtime instance with the page
+ *  bundles — eliminates the dual-package hazard that produces NG0201.
+ *
+ *  After this build, `@angular/compiler` is no longer required at runtime
+ *  for AOT-mode builds: every partial `ɵɵngDeclare*` has been linked into
+ *  final ɵdir/ɵcmp/ɵfac definitions in the vendor output. */
+export declare const buildAngularServerVendor: (buildDir: string, directories?: string[], linkerJitMode?: boolean) => Promise<string[]>;
+/** Absolute filesystem paths to server vendor files, for `rewriteImports`
+ *  on server-side bundles and for runtime resolution in `getAngularDeps`. */
+export declare const computeAngularServerVendorPaths: (buildDir: string, specifiers: string[]) => Record<string, string>;
+/** Async server-vendor path map: scans source + transitive deps, then
+ *  produces absolute filesystem paths for every @angular/* spec the project
+ *  uses (plus the always-vendored server-only specs). Mirrors
+ *  `computeAngularVendorPathsAsync` but for server-side rewriting. */
+export declare const computeAngularServerVendorPathsAsync: (buildDir: string, directories?: string[], linkerJitMode?: boolean) => Promise<Record<string, string>>;

package/dist/src/build/buildDepVendor.d.ts

@@ -0,0 +1,2 @@
+export declare const buildDepVendor: (buildDir: string, directories: string[]) => Promise<Record<string, string>>;
+export declare const computeDepVendorPaths: (directories: string[]) => Promise<Record<string, string>>;

package/dist/src/build/buildEmberVendor.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Build vendor bundles for Ember client runtime. Output goes to
+ * `{buildDir}/ember/vendor/` with stable, hash-free filenames so the
+ * compiled-page rewriter can produce deterministic import URLs.
+ */
+export declare const buildEmberVendor: (buildDir: string, cwd?: string) => Promise<string[]>;
+/**
+ * Compute the bare-specifier → URL map without running the build. The
+ * dev module server uses this to rewrite user-source imports of
+ * `@glimmer/component` / `@ember/template-compiler` / etc. to the stable
+ * `/ember/vendor/<safe>.js` paths.
+ */
+export declare const computeEmberVendorPaths: () => Record<string, string>;
+/**
+ * Resolve the absolute path of a server-only Ember runtime module.
+ * Server-side imports of `@simple-dom/document` / `@simple-dom/serializer`
+ * dodge the vendor bundle entirely — Node's ESM resolver handles them
+ * directly via the project's node_modules. The Ember pageHandler uses
+ * this to dynamically import the polyfills on the SSR path.
+ *
+ * `@simple-dom/document` lives inside ember-source; `@simple-dom/serializer`
+ * is a standalone npm package.
+ */
+export declare const resolveEmberServerModulePath: (specifier: string, cwd?: string) => string;