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

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

@@ -1,29 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,16 +0,0 @@
-/** 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

@@ -1,57 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,18 +0,0 @@
-/** 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

@@ -1,2 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

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

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

@@ -1,9 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

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

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

@@ -1,48 +0,0 @@
-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

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

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

@@ -1,12 +0,0 @@
-/** 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

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

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

@@ -1,5 +0,0 @@
-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

@@ -1,19 +0,0 @@
-/**
- * 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

@@ -1,6 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,40 +0,0 @@
-/** 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

@@ -1,2 +0,0 @@
-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

@@ -1,24 +0,0 @@
-/**
- * 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;