@supacloud/app 0.2.0 → 0.5.0

package/dist/inject.d.ts

@@ -0,0 +1,81 @@
+import type { EnvironmentProviders, Provider, Token } from "./provider";
+import { InjectionToken } from "./token";
+export interface InjectFlags {
+    /** If true, returns undefined instead of throwing when token is not found. */
+    optional?: boolean;
+    /** If true, requires token to be resolved from current local injector. */
+    self?: boolean;
+    /** If true, skips current local injector and resolves from parent. */
+    skipSelf?: boolean;
+    /** If true, resolves from host injector. */
+    host?: boolean;
+}
+export interface InjectorLike {
+    get<T>(token: Token<T>, options?: InjectFlags): T | undefined;
+    readonly parent?: InjectorLike;
+}
+/**
+ * Returns the current active Injector context, or null if not inside an injection context.
+ */
+export declare function getActiveInjector(): InjectorLike | null;
+/**
+ * Built-in injection token for resolving the active injector instance.
+ * Modeled directly after Angular's INJECTOR token.
+ */
+export declare const INJECTOR: InjectionToken<InjectorLike>;
+/**
+ * Executes a function within the scope of a specific injector.
+ * Modeled directly after Angular's `runInInjectionContext(injector, fn)`.
+ */
+export declare function runInInjectionContext<R>(injector: InjectorLike, fn: () => R): R;
+/**
+ * Resolves a token from the currently active injection context.
+ * Modeled directly after Angular's `inject(token)`.
+ *
+ * Can be used in:
+ * 1. Property initializers of classes
+ * 2. Constructors
+ * 3. Functional route guards (CanActivateFn)
+ * 4. Route resolvers (ResolveFn)
+ * 5. Factory providers
+ * 6. Code executed inside `runInInjectionContext`
+ */
+export declare function inject<T>(token: Token<T>, options?: InjectFlags): T;
+/**
+ * Injects all instances registered for a multi-provider token.
+ * Modeled after Angular's multi-provider injection.
+ */
+export declare function injectAll<T>(token: Token<T>): T[];
+/**
+ * Creates a hierarchical child injector that inherits providers from a parent injector.
+ * Modeled directly after Angular's hierarchical injectors.
+ */
+export declare function createChildInjector(parent: InjectorLike, localProviders?: Map<Token<unknown> | string, unknown> | Record<string, unknown>): InjectorLike & {
+    readonly parent: InjectorLike;
+};
+/**
+ * Asserts that execution is currently within an injection context.
+ * Modeled after Angular's `assertInInjectionContext`.
+ */
+export declare function assertInInjectionContext(fnName: string): void;
+/**
+ * Injects the AbortSignal of the active DestroyRef.
+ * Automatically aborted when the active context or service is destroyed.
+ * Modeled after Angular's DestroyRef signal pattern.
+ */
+export declare function injectDestroySignal(): AbortSignal;
+export interface EnvironmentInjector extends InjectorLike {
+    get<T>(token: Token<T>, options?: InjectFlags): T;
+    get<T>(token: Token<T>, notFoundValue: T, options?: InjectFlags): T;
+    runInContext<R>(fn: () => R): R;
+    destroy(): void;
+    readonly destroyed: boolean;
+    readonly parent?: InjectorLike;
+}
+/**
+ * Creates an EnvironmentInjector with an isolated dependency scope and lifecycle.
+ * Modeled directly after Angular 14+ createEnvironmentInjector.
+ * Automatically executes all ENVIRONMENT_INITIALIZER / APP_INITIALIZER hooks upon creation,
+ * and executes DestroyRef teardowns and OnDestroy hooks upon destroy().
+ */
+export declare function createEnvironmentInjector(providers: Array<Provider | EnvironmentProviders>, parent?: InjectorLike): EnvironmentInjector;

package/dist/input_transform.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Angular 16+ input transforms for parameter and attribute coercion.
+ * Directly modeled after Angular's booleanAttribute and numberAttribute.
+ */
+/**
+ * Transforms an incoming value to a boolean following Angular booleanAttribute semantics:
+ * - boolean values are preserved
+ * - empty strings ('') and 'true' (or any truthy string except 'false') are coerced to true
+ * - 'false', false, null, and undefined are coerced to false
+ */
+export declare function booleanAttribute(value: unknown): boolean;
+/**
+ * Transforms an incoming value to a number following Angular numberAttribute semantics:
+ * - number values are preserved (unless NaN)
+ * - valid numeric strings are parsed with parseFloat
+ * - invalid or non-numeric values fall back to fallbackValue (defaults to NaN)
+ */
+export declare function numberAttribute(value: unknown, fallbackValue?: number): number;

package/dist/interceptor.d.ts

@@ -0,0 +1,33 @@
+import type { HttpContext } from "./http_context";
+/**
+ * Angular-inspired functional HTTP interceptor pipeline.
+ * Modeled after Angular 15+ HttpInterceptorFn and withInterceptors API.
+ */
+export interface HttpRequestPayload {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body?: unknown;
+    context?: HttpContext;
+}
+export type HttpInterceptorFn = (req: HttpRequestPayload, next: (req: HttpRequestPayload) => Promise<Response>) => Promise<Response>;
+/**
+ * Chains multiple functional interceptors into a single interceptor pipeline.
+ */
+export declare function withInterceptors(...interceptors: HttpInterceptorFn[]): HttpInterceptorFn[];
+/**
+ * Creates an interceptor that appends an Authorization: Bearer <token> header.
+ */
+export declare function createBearerAuthInterceptor(tokenOrGetter: string | (() => string | Promise<string>)): HttpInterceptorFn;
+/**
+ * Creates an interceptor that merges static or dynamic headers.
+ */
+export declare function createHeaderInterceptor(headers: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>)): HttpInterceptorFn;
+/**
+ * Creates an interceptor that aborts the request after timeoutMs.
+ */
+export declare function createTimeoutInterceptor(timeoutMs: number): HttpInterceptorFn;
+/**
+ * Creates an interceptor that retries on failed requests up to maxRetries.
+ */
+export declare function createRetryInterceptor(maxRetries: number, delayMs?: number): HttpInterceptorFn;

package/dist/location.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Normalizes a URL path by stripping duplicate slashes and ensuring single leading slash.
+ * Modeled directly after Angular's Location.normalize in @angular/common.
+ */
+export declare function normalizePath(path: string): string;
+/**
+ * Strips the trailing slash from a URL path, unless the path is root '/'.
+ * Modeled directly after Angular's Location.stripTrailingSlash.
+ */
+export declare function stripTrailingSlash(path: string): string;
+/**
+ * Joins two path parts with a single slash.
+ * Modeled directly after Angular's Location.joinWithSlash.
+ */
+export declare function joinWithSlash(start: string, end: string): string;

package/dist/pipe.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Angular-style Pipes & Transformation Suite (@angular/core).
+ * Enables pure and declarative data transformations for route responses,
+ * payloads, and presentation layers.
+ */
+export interface PipeTransform<T = any, R = any> {
+    transform(value: T, ...args: any[]): R;
+}
+export interface PipeMetadata {
+    name: string;
+    pure?: boolean;
+    standalone?: boolean;
+}
+export declare function Pipe(options: PipeMetadata): ClassDecorator;
+export declare function getPipeMetadata(target: any): PipeMetadata | undefined;
+/**
+ * Transforms text to uppercase.
+ */
+export declare class UpperCasePipe implements PipeTransform<string | null | undefined, string> {
+    transform(value: string | null | undefined): string;
+}
+/**
+ * Transforms text to lowercase.
+ */
+export declare class LowerCasePipe implements PipeTransform<string | null | undefined, string> {
+    transform(value: string | null | undefined): string;
+}
+/**
+ * Trims leading and trailing whitespace.
+ */
+export declare class TrimPipe implements PipeTransform<string | null | undefined, string> {
+    transform(value: string | null | undefined): string;
+}
+/**
+ * Serializes value into a formatted JSON string.
+ */
+export declare class JsonPipe implements PipeTransform<unknown, string> {
+    transform(value: unknown, space?: number): string;
+}
+/**
+ * Formats a Date or timestamp into an ISO string or localized string.
+ */
+export declare class DatePipe implements PipeTransform<Date | string | number | null | undefined, string> {
+    transform(value: Date | string | number | null | undefined, format?: "iso" | "locale"): string;
+}

package/dist/platform.d.ts

@@ -0,0 +1,33 @@
+import { InjectionToken } from "./token";
+export declare const PLATFORM_SERVER_ID = "server";
+export declare const PLATFORM_BROWSER_ID = "browser";
+export declare const PLATFORM_EDGE_ID = "edge";
+export type PlatformId = "server" | "browser" | "edge";
+/**
+ * Detects the runtime execution platform.
+ */
+export declare function detectPlatform(): PlatformId;
+/**
+ * A DI Token representing the main rendering context's Document.
+ * Modeled directly after Angular's DOCUMENT token in @angular/common.
+ */
+export declare const DOCUMENT: InjectionToken<any>;
+/**
+ * Built-in injection token for platform identification.
+ * Modeled directly after Angular's PLATFORM_ID.
+ */
+export declare const PLATFORM_ID: InjectionToken<string>;
+/**
+ * Returns whether a platform id represents a browser environment.
+ * Modeled directly after Angular's isPlatformBrowser.
+ */
+export declare function isPlatformBrowser(platformId: unknown): boolean;
+/**
+ * Returns whether a platform id represents a server-side environment (Node.js/Bun/Edge).
+ * Modeled directly after Angular's isPlatformServer.
+ */
+export declare function isPlatformServer(platformId: unknown): boolean;
+/**
+ * Returns whether a platform id represents an edge runtime environment.
+ */
+export declare function isPlatformEdge(platformId: unknown): boolean;

package/dist/provider.d.ts

@@ -1,18 +1,23 @@
 import type { InjectionToken } from "./token";
+import type { ForwardRefFn } from "./forward_ref";
 import type { Scope } from "./scope";
 /** A class usable as a DI token / provider implementation. */
 export interface Type<T> {
     new (...args: any[]): T;
 }
 /** Anything that can identify a provider: an InjectionToken or a class. */
-export type Token<T = any> = InjectionToken<T> | Type<T>;
+export type Token<T = any> = InjectionToken<T> | Type<T> | ForwardRefFn<InjectionToken<T> | Type<T>>;
 interface BaseProvider {
     /** Overrides the scope derived from @Injectable / token defaults. */
     scope?: Scope;
+    /**
+     * When true, multiple providers can contribute to this token as an array of instances (Angular multi-providers).
+     */
+    multi?: boolean;
 }
 export interface ClassProvider<T = any> extends BaseProvider {
     provide: Token<T>;
-    useClass: Type<T>;
+    useClass: Type<T> | ForwardRefFn<Type<T>>;
     /** Explicit dependency tokens, positional (constructor order). */
     deps?: Token[];
 }
@@ -35,4 +40,29 @@ export declare function isClassProvider<T>(provider: Provider<T>): provider is C
 export declare function isValueProvider<T>(provider: Provider<T>): provider is ValueProvider<T>;
 export declare function isFactoryProvider<T>(provider: Provider<T>): provider is FactoryProvider<T>;
 export declare function isExistingProvider<T>(provider: Provider<T>): provider is ExistingProvider<T>;
+/**
+ * Encapsulates a set of providers created by functional provideXxx APIs.
+ * Modeled directly after Angular's EnvironmentProviders.
+ */
+export interface EnvironmentProviders {
+    ɵproviders: Provider[];
+}
+export declare function makeEnvironmentProviders(providers: Provider[]): EnvironmentProviders;
+export declare function isEnvironmentProviders(value: unknown): value is EnvironmentProviders;
+export declare function flattenProviders(providers: Array<Provider | EnvironmentProviders>): Provider[];
+/**
+ * Configures an application initializer function that executes during startup before accepting requests.
+ * Modeled after Angular's provideAppInitializer.
+ */
+export declare function provideAppInitializer(initializerFn: () => void | Promise<void>): EnvironmentProviders;
+/**
+ * Configures an environment/application initializer that executes during startup before accepting requests.
+ * Modeled directly after Angular 15+ provideEnvironmentInitializer.
+ */
+export declare function provideEnvironmentInitializer(initializerFn: () => void | Promise<void>): EnvironmentProviders;
+/**
+ * Functional provider helper to register an InjectionToken with a static value or factory.
+ * Modeled after Angular's provideToken pattern.
+ */
+export declare function provideToken<T>(token: Token<T>, value: T): EnvironmentProviders;
 export {};

package/dist/resource.d.ts

@@ -0,0 +1,40 @@
+import { type Signal } from "./signal";
+export type ResourceStatus = "idle" | "loading" | "resolved" | "error";
+export interface ResourceLoaderParams<R> {
+    request: R;
+    abortSignal: AbortSignal;
+    previous?: {
+        status: ResourceStatus;
+    };
+}
+export interface ResourceOptions<T, R = unknown> {
+    /** Reactive request getter. Re-executes loader whenever signals read inside change. */
+    request?: () => R;
+    /** Asynchronous loader that fetches data for the request. */
+    loader: (params: ResourceLoaderParams<R>) => Promise<T>;
+    /** Optional initial value before first load resolves. */
+    initialValue?: T;
+}
+export interface ResourceRef<T> {
+    /** The current loaded value, or undefined if not yet resolved. */
+    readonly value: Signal<T | undefined>;
+    /** The current lifecycle status: 'idle' | 'loading' | 'resolved' | 'error'. */
+    readonly status: Signal<ResourceStatus>;
+    /** The error encountered during the last load, if any. */
+    readonly error: Signal<unknown | undefined>;
+    /** Boolean indicating whether a load is currently in progress. */
+    readonly isLoading: Signal<boolean>;
+    /** Triggers a reload using the current request. */
+    reload(): void;
+    /** Sets the value directly, transitioning status to 'resolved'. */
+    set(value: T): void;
+    /** Updates the value directly using a transformation function. */
+    update(updateFn: (current: T | undefined) => T): void;
+    /** Destroys the resource, aborting any active requests and disposing internal effects. */
+    destroy(): void;
+}
+/**
+ * Creates an asynchronous resource driven by reactive signals.
+ * Modeled directly after Angular 19's resource() API.
+ */
+export declare function resource<T, R = unknown>(options: ResourceOptions<T, R>): ResourceRef<T>;

package/dist/route_match.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Result of matching a URL against a route pattern.
+ * Modeled after Angular Router's UrlMatcher / UrlSegment matching.
+ */
+export interface RouteMatchResult {
+    matched: boolean;
+    params: Record<string, string>;
+    remainingUrl?: string;
+}
+/**
+ * Matches a URL against a parameterized route pattern (e.g. `/users/:id/edit`).
+ * Supports Angular-style `pathMatch: "full" | "prefix"`.
+ */
+export declare function matchRoute(pattern: string, url: string, strategy?: "full" | "prefix"): RouteMatchResult;

package/dist/route_pipeline.d.ts

@@ -0,0 +1,74 @@
+import type { CanActivateFn, CanDeactivateFn, CanMatchFn, ResolveFn } from "./decorators";
+import { type TitleStrategy } from "./title_strategy";
+export interface NavigationExtras {
+    status?: number;
+    skipLocationChange?: boolean;
+    queryParams?: Record<string, unknown>;
+    headers?: Record<string, string>;
+}
+/**
+ * Angular 18+ RedirectCommand for functional guards, resolvers, and handlers.
+ * Allows returning a redirect destination directly from route pipelines.
+ */
+export declare class RedirectCommand {
+    readonly redirectTo: string | {
+        toString(): string;
+    };
+    readonly navigationExtras?: NavigationExtras | undefined;
+    constructor(redirectTo: string | {
+        toString(): string;
+    }, navigationExtras?: NavigationExtras | undefined);
+}
+export declare function isRedirectCommand(val: unknown): val is RedirectCommand;
+export interface RoutePipelineContext {
+    url: string;
+    method: string;
+    params?: Record<string, string>;
+    query?: Record<string, unknown>;
+    body?: unknown;
+    headers?: Record<string, string>;
+    resolved?: Record<string, unknown>;
+    data?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface RoutePipelineDefinition {
+    path: string;
+    method: string;
+    handler: ((...args: any[]) => any) | string;
+    guards?: Array<CanActivateFn | string>;
+    canMatch?: Array<CanMatchFn | string>;
+    canDeactivate?: Array<CanDeactivateFn | string>;
+    resolvers?: Record<string, ResolveFn | string>;
+    title?: string;
+    data?: Record<string, unknown>;
+    invoker?: (controller: unknown, request: RoutePipelineContext) => Promise<unknown> | unknown;
+}
+export interface RoutePipelineResult<T = unknown> {
+    matched: boolean;
+    status: number;
+    body?: T;
+    error?: string;
+    resolvedData?: Record<string, unknown>;
+    redirect?: string;
+    headers?: Record<string, string>;
+}
+export type RouterEventType = "NavigationStart" | "RoutesRecognized" | "GuardsCheckStart" | "GuardsCheckEnd" | "ResolveStart" | "ResolveEnd" | "ExecutionStart" | "ExecutionEnd" | "NavigationEnd" | "NavigationCancel" | "NavigationError";
+export interface RouterEvent {
+    type: RouterEventType;
+    url: string;
+    timestamp: number;
+    data?: unknown;
+}
+export interface RoutePipelineOptions {
+    onEvent?: (event: RouterEvent) => void;
+    titleStrategy?: TitleStrategy;
+}
+/**
+ * Executes a full route lifecycle pipeline matching Angular Router execution semantics:
+ * 1. canMatch guards check if route can match
+ * 2. canActivate guards check access permissions
+ * 3. resolvers prefetch data concurrently
+ * 4. handler executes
+ * 5. canDeactivate guards check teardown/exit safety
+ */
+export declare function executeRoutePipeline<T = unknown>(route: RoutePipelineDefinition, ctx: RoutePipelineContext, componentInstance?: any, options?: RoutePipelineOptions): Promise<RoutePipelineResult<T>>;

package/dist/route_provider.d.ts

@@ -0,0 +1,39 @@
+import { InjectionToken } from "./token";
+import type { EnvironmentProviders, Provider, Type } from "./provider";
+import type { RouteDefinition } from "./decorators";
+import { type TitleStrategy } from "./title_strategy";
+export declare const ROUTE_CONFIG: InjectionToken<RouteDefinition[]>;
+/**
+ * Built-in injection token for the application base href.
+ * Modeled directly after Angular's APP_BASE_HREF in @angular/common.
+ */
+export declare const APP_BASE_HREF: InjectionToken<string>;
+export interface RouterFeature {
+    kind: string;
+    providers: Provider[];
+}
+export interface RouterConfigOptions {
+    onSameUrlNavigation?: "reload" | "ignore";
+    paramsInheritanceStrategy?: "emptyOnly" | "always";
+}
+export declare const ROUTER_CONFIGURATION: InjectionToken<RouterConfigOptions>;
+/**
+ * Feature flag enabling automatic binding of route and query parameters to component/handler inputs.
+ * Modeled after Angular 16+ withComponentInputBinding().
+ */
+export declare function withComponentInputBinding(): RouterFeature;
+/**
+ * Configures global router behavior options.
+ * Modeled after Angular 15+ withRouterConfig().
+ */
+export declare function withRouterConfig(options: RouterConfigOptions): RouterFeature;
+/**
+ * Registers a custom TitleStrategy for page title updates upon navigation.
+ * Modeled after Angular 14+ withTitleStrategy().
+ */
+export declare function withTitleStrategy(strategy: TitleStrategy | Type<TitleStrategy>): RouterFeature;
+/**
+ * Provides application-wide route configuration and router features.
+ * Modeled after Angular 15+ standalone provideRouter.
+ */
+export declare function provideRouter(routes: RouteDefinition[], ...features: RouterFeature[]): EnvironmentProviders;

package/dist/signal.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Zero-dependency, lightweight reactive signals modeled after Angular Signals and TC39 Signals.
+ * Provides fine-grained reactive state without RxJS or runtime reflection.
+ */
+export interface Signal<T> {
+    (): T;
+}
+export interface WritableSignal<T> extends Signal<T> {
+    set(value: T): void;
+    update(updateFn: (current: T) => T): void;
+    asReadonly(): Signal<T>;
+}
+/**
+ * Creates a writable signal with initial value.
+ */
+export declare function signal<T>(initialValue: T): WritableSignal<T>;
+/**
+ * Creates a computed, read-only signal derived from other signals.
+ * Evaluates lazily and caches the result until dependencies change.
+ */
+export declare function computed<T>(computation: () => T): Signal<T>;
+/**
+ * Creates a reactive effect that runs computation immediately and re-runs whenever any read signal changes.
+ * Returns a teardown function.
+ */
+export declare function effect(effectFn: () => void | (() => void)): () => void;
+/**
+ * Runs a function without registering signal dependencies.
+ */
+export declare function untracked<T>(fn: () => T): T;
+export interface LinkedSignalOptions<S, D> {
+    source: () => S;
+    computation: (source: S, previous?: {
+        source: S;
+        value: D;
+    }) => D;
+    equal?: (a: D, b: D) => boolean;
+}
+/**
+ * Creates a writable signal whose value is linked to a source reactive computation.
+ * When the source dependencies change, the linkedSignal automatically recomputes its value.
+ * Unlike a standard computed signal, a linkedSignal is writable and can be manually modified.
+ * Modeled directly after Angular 19's linkedSignal.
+ */
+export declare function linkedSignal<D>(computation: () => D, options?: {
+    equal?: (a: D, b: D) => boolean;
+}): WritableSignal<D>;
+export declare function linkedSignal<S, D = S>(options: LinkedSignalOptions<S, D>): WritableSignal<D>;

package/dist/testing.d.ts

@@ -0,0 +1,43 @@
+import type { EnvironmentProviders, Provider, Token } from "./provider";
+import { type InjectFlags } from "./inject";
+export interface TestModuleMetadata {
+    providers?: Array<Provider | EnvironmentProviders>;
+    imports?: Array<{
+        providers?: Array<Provider | EnvironmentProviders>;
+    } | any>;
+}
+/**
+ * Unit testing environment for SupaCloud services and controllers.
+ * Modeled directly after Angular's TestBed.
+ */
+export declare class TestBed {
+    private static declaredProviders;
+    private static overriddenProviders;
+    private static activeInjector;
+    private static instances;
+    /**
+     * Configures the testing module with providers and imports.
+     */
+    static configureTestingModule(moduleDef: TestModuleMetadata): typeof TestBed;
+    /**
+     * Overrides a provider token with a test double or mock.
+     */
+    static overrideProvider(token: Token<unknown>, provider: Provider): typeof TestBed;
+    /**
+     * Injects and resolves a dependency from the test environment.
+     */
+    static inject<T>(token: Token<T>, notFoundValue?: T, flags?: InjectFlags): T;
+    /**
+     * Injects all instances registered for a multi-provider token from the test environment.
+     */
+    static injectAll<T>(token: Token<T>): T[];
+    /**
+     * Runs a function inside the TestBed injection context.
+     */
+    static run<R>(fn: () => R): R;
+    /**
+     * Resets the testing environment, clearing providers, mocks, and instantiated singletons.
+     */
+    static resetTestingModule(): typeof TestBed;
+    private static getOrCreateInjector;
+}

package/dist/title_strategy.d.ts

@@ -0,0 +1,18 @@
+import { InjectionToken } from "./token";
+import type { RoutePipelineContext } from "./route_pipeline";
+/**
+ * Strategy interface for updating application document / page titles upon navigation.
+ * Modeled directly after Angular 14+ TitleStrategy.
+ */
+export declare abstract class TitleStrategy {
+    abstract updateTitle(title: string | undefined, ctx?: RoutePipelineContext): void;
+    buildTitle(title: string | undefined, appPrefix?: string): string | undefined;
+}
+/**
+ * Default implementation of TitleStrategy.
+ * Updates global document.title when available, and records the resolved title in route context data.
+ */
+export declare class DefaultTitleStrategy extends TitleStrategy {
+    updateTitle(title: string | undefined, ctx?: RoutePipelineContext): void;
+}
+export declare const TITLE_STRATEGY: InjectionToken<TitleStrategy>;

package/dist/token.d.ts

@@ -2,6 +2,8 @@ import type { Scope } from "./scope";
 export interface InjectionTokenOptions<T> {
     /** Optional default factory used when no explicit provider is registered. */
     factory?: () => T;
+    /** Automatically provide in the root injector context without manual module declaration (Angular tree-shakable provider). */
+    providedIn?: "root";
     /** Default scope when the token itself is used as a provider. */
     scope?: Scope;
 }
@@ -12,6 +14,7 @@ export interface InjectionTokenOptions<T> {
 export declare class InjectionToken<T> {
     readonly name: string;
     readonly factory?: () => T;
+    readonly providedIn?: "root";
     readonly scope?: Scope;
     constructor(name: string, options?: InjectionTokenOptions<T>);
     toString(): string;

package/dist/transfer_state.d.ts

@@ -0,0 +1,52 @@
+import { InjectionToken } from "./token";
+export type StateKey<T> = string & {
+    readonly __type_brand?: T;
+};
+/**
+ * Creates a type-safe StateKey for TransferState.
+ * Modeled directly after Angular's makeStateKey.
+ */
+export declare function makeStateKey<T>(key: string): StateKey<T>;
+/**
+ * Key-value store used to transfer application state between server and client (SSR / Edge hydration).
+ * Modeled directly after Angular Universal TransferState.
+ */
+export declare class TransferState {
+    private store;
+    /**
+     * Retrieves the value associated with the key, or defaultValue if not present.
+     */
+    get<T>(key: StateKey<T> | string, defaultValue: T): T;
+    /**
+     * Sets the value for the given key.
+     */
+    set<T>(key: StateKey<T> | string, value: T): void;
+    /**
+     * Checks whether the key exists in the store.
+     */
+    hasKey<T>(key: StateKey<T> | string): boolean;
+    /**
+     * Removes a key from the store.
+     */
+    remove<T>(key: StateKey<T> | string): void;
+    /**
+     * Checks whether the store is empty.
+     */
+    isEmpty(): boolean;
+    /**
+     * Serializes the current state store into a JSON string.
+     */
+    toJson(): string;
+    /**
+     * Deserializes a JSON string into a TransferState store.
+     */
+    static fromJson(json: string): TransferState;
+    /**
+     * Creates a TransferState initialized with a plain record object.
+     */
+    static fromObject(record: Record<string, unknown>): TransferState;
+}
+/**
+ * Built-in injection token for TransferState.
+ */
+export declare const TRANSFER_STATE: InjectionToken<TransferState>;