@sjcx/vorma 0.0.0-pre.2 → 0.0.0-pre.4

package/dist/client/react/link.d.ts

@@ -1,27 +0,0 @@
-import { type ComponentProps, type JSX, type ReactNode } from "react";
-import type { NavigationTargetInput } from "../contracts.ts";
-import { type LinkMatchRules, type LinkState } from "../links.ts";
-import type { NavigationOptions } from "../types.ts";
-export type LinkBehaviorProps = {
-    readonly prefetch?: "intent" | "none";
-    readonly prefetchDelayMs?: number;
-    readonly visitOnPointerDown?: boolean;
-    /** Search and fragment comparisons are opt-in; pathname matching is automatic. */
-    readonly matchRules?: LinkMatchRules;
-    readonly replace?: NavigationOptions["replace"];
-    readonly scrollToTop?: NavigationOptions["scrollToTop"];
-    readonly scrollToFragment?: NavigationOptions["scrollToFragment"];
-    readonly historyState?: unknown;
-    readonly skipWorkIndicator?: boolean;
-};
-export type DefaultLinkProps = Partial<LinkBehaviorProps & Omit<ComponentProps<"a">, "href">>;
-export type LinkProps = NavigationTargetInput & LinkBehaviorProps & Omit<ComponentProps<"a">, "href"> & {
-    readonly children?: ReactNode;
-};
-/** The active and pending facts of a target under its match rules; an invalid target follows the applicable route boundary. */
-export declare function useLinkState(input: NavigationTargetInput & {
-    readonly matchRules?: LinkMatchRules;
-}): LinkState;
-declare function LinkComponent(rawProps: LinkProps): JSX.Element;
-export declare const Link: import("react").MemoExoticComponent<typeof LinkComponent>;
-export {};

package/dist/client/react/view.d.ts

@@ -1,86 +0,0 @@
-import { type Effect, type Layer } from "effect";
-import type { Atom } from "effect/unstable/reactivity";
-import { type ComponentType, type JSX } from "react";
-import type { ClientLoaderContext, RoutePattern } from "../contracts.ts";
-import { type RouteContext } from "../route-context.ts";
-import { clientRuntime, universalRuntime, type ClientCoordinatorService } from "../runtime.ts";
-import type { BoundaryError } from "../types.ts";
-import type { RouteTransitionFn, ViewDefinition } from "../view-definition.ts";
-import type { DefaultLinkProps } from "./link.tsx";
-declare const UI_VIEW_TYPES: unique symbol;
-export type ApplicationContext = {
-    readonly coordinator: ClientCoordinatorService;
-    readonly defaultErrorBoundary: ComponentType<{
-        readonly error: BoundaryError;
-    }>;
-    readonly defaultLinkProps: DefaultLinkProps | undefined;
-};
-export declare const ApplicationProvider: import("react").Provider<ApplicationContext | null>;
-/** The mounted application. A Vorma component outside one cannot work, and React's protocol for that is a throw to the caller. */
-export declare function useApplication(): ApplicationContext;
-export type UiViewClientLoaderContract<Success = unknown, Error = unknown, Requirements = unknown> = {
-    readonly success: Success;
-    readonly error: Error;
-    readonly requirements: Requirements;
-};
-type OptionalClientLoaderContract = UiViewClientLoaderContract | undefined;
-type RuntimeServices<Runtime> = Runtime extends Atom.AtomRuntime<infer Services, unknown> ? Services : never;
-/** A route's runtime: the application runtime's services plus the view's local Layers. */
-export type RouteRuntime<Base, LocalServices, LocalError> = Base extends Atom.AtomRuntime<infer Services, infer Error> ? Atom.AtomRuntime<Services | LocalServices, Error | LocalError> : never;
-export type ViewProps<Pattern extends string = RoutePattern, ClientLoaderContract extends OptionalClientLoaderContract = OptionalClientLoaderContract, ClientOnlyServices = never, ClientOnlyServicesError = never, UniversalServices = never, UniversalServicesError = never> = RouteContext<Extract<Pattern, RoutePattern>> & {
-    readonly Outlet: ComponentType;
-    readonly clientRuntime: RouteRuntime<typeof clientRuntime, ClientOnlyServices | UniversalServices, ClientOnlyServicesError | UniversalServicesError>;
-    readonly universalRuntime: RouteRuntime<typeof universalRuntime, UniversalServices, UniversalServicesError>;
-    readonly [UI_VIEW_TYPES]?: {
-        readonly clientLoader: ClientLoaderContract;
-    };
-};
-type ErrorBoundaryComponent = ComponentType<{
-    readonly error: BoundaryError;
-}>;
-export type UiViewDefinition<Pattern extends string = RoutePattern, ClientLoaderContract extends OptionalClientLoaderContract = undefined> = ViewDefinition & {
-    readonly pattern: Pattern;
-    readonly component: ComponentType<never>;
-    readonly descendantErrorBoundary?: ErrorBoundaryComponent;
-    readonly [UI_VIEW_TYPES]?: {
-        readonly clientLoader: ClientLoaderContract;
-    };
-};
-/** The client-loader contract the generated declarations read from a view module. */
-export type GetUiViewClientLoaderContract<Definition> = Definition extends UiViewDefinition<RoutePattern, infer ClientLoaderContract> ? ClientLoaderContract : undefined;
-type ViewField<Definition, Key extends PropertyKey> = Key extends keyof Definition ? Exclude<Definition[Key], undefined> : never;
-type ViewLayerServices<Value> = Value extends Layer.Layer<infer Services, unknown, unknown> ? Services : never;
-type RequiredViewField<Definition, Key extends PropertyKey> = Key extends keyof Definition ? Definition extends {
-    readonly [Property in Key]: unknown;
-} ? Definition[Key] : never : never;
-type ViewHookRequirements<Value> = Value extends RouteTransitionFn<infer Requirements> ? Requirements : never;
-/** Checks each authored definition's providers; an optional layer cannot guarantee a service. */
-type MissingRouteTransitionServices<Definition> = Definition extends unknown ? Exclude<ViewHookRequirements<ViewField<Definition, "beforeRouteCommit" | "beforeRouteReplacement">>, RuntimeServices<typeof clientRuntime> | ViewLayerServices<RequiredViewField<Definition, "clientOnlyServices" | "universalServices">>> : never;
-type RouteTransitionRequirementCheck<Definition> = [
-    MissingRouteTransitionServices<Definition>
-] extends [never] ? unknown : {
-    readonly unsatisfiedRouteTransitionRequirement: never;
-};
-type UiViewOptions<Pattern extends string, ClientLoaderContract extends OptionalClientLoaderContract, ClientOnlyServices, ClientOnlyServicesError, UniversalServices, UniversalServicesError> = {
-    readonly pattern: Pattern;
-    readonly component: ComponentType<ViewProps<Pattern, ClientLoaderContract, ClientOnlyServices, ClientOnlyServicesError, UniversalServices, UniversalServicesError>>;
-    readonly descendantErrorBoundary?: ErrorBoundaryComponent;
-    readonly beforeRouteCommit?: RouteTransitionFn<unknown>;
-    readonly beforeRouteReplacement?: RouteTransitionFn<unknown>;
-    readonly reuseLoaderDataWithin?: ViewDefinition["reuseLoaderDataWithin"];
-    readonly rerunClientLoaderOnHotUpdate?: boolean;
-    readonly clientOnlyServices?: Layer.Layer<ClientOnlyServices, ClientOnlyServicesError, RuntimeServices<typeof clientRuntime> | UniversalServices>;
-    readonly universalServices?: Layer.Layer<UniversalServices, UniversalServicesError, RuntimeServices<typeof universalRuntime>>;
-};
-declare function makeUiView<Definition, const Pattern extends string, ClientLoaderSuccess, ClientLoaderError, ClientLoaderRequirements extends RuntimeServices<typeof clientRuntime> | NoInfer<ClientOnlyServices | UniversalServices>, ClientOnlyServices = never, ClientOnlyServicesError = never, UniversalServices = never, UniversalServicesError = never>(definition: Definition & RouteTransitionRequirementCheck<Definition> & UiViewOptions<Pattern, UiViewClientLoaderContract<ClientLoaderSuccess, ClientLoaderError, ClientLoaderRequirements>, ClientOnlyServices, ClientOnlyServicesError, UniversalServices, UniversalServicesError> & {
-    readonly clientLoader: (context: ClientLoaderContext<Extract<Pattern, RoutePattern>>) => Effect.Effect<ClientLoaderSuccess, ClientLoaderError, ClientLoaderRequirements>;
-}): UiViewDefinition<Pattern, UiViewClientLoaderContract<ClientLoaderSuccess, ClientLoaderError, ClientLoaderRequirements>>;
-declare function makeUiView<Definition, const Pattern extends string, ClientOnlyServices = never, ClientOnlyServicesError = never, UniversalServices = never, UniversalServicesError = never>(definition: Definition & RouteTransitionRequirementCheck<Definition> & UiViewOptions<Pattern, undefined, ClientOnlyServices, ClientOnlyServicesError, UniversalServices, UniversalServicesError> & {
-    readonly clientLoader?: never;
-}): UiViewDefinition<Pattern>;
-export declare const UiView: {
-    readonly make: typeof makeUiView;
-};
-/** The application boundary encloses every route. */
-export declare function RootOutlet(): JSX.Element;
-export {};

package/dist/client/request.d.ts

@@ -1,16 +0,0 @@
-import { Effect, type Option } from "effect";
-import type { HttpClientRequest } from "effect/unstable/http";
-import type { OperationId, RequestKind } from "./types.ts";
-/** The request and framework identity supplied to application request decoration. */
-export type ClientRequestContext = {
-    readonly request: HttpClientRequest.HttpClientRequest;
-    readonly requestKind: RequestKind;
-    readonly operationId: Option.Option<OperationId>;
-};
-/** An application request decorator whose Effect may use assembled client services. */
-export type PrepareRequestFn<Requirements = never> = (context: ClientRequestContext) => Effect.Effect<HttpClientRequest.HttpClientRequest, unknown, Requirements>;
-/** Applies the application's request transformation before dispatch. */
-export declare function prepareClientRequest<Requirements>(input: {
-    readonly context: ClientRequestContext;
-    readonly prepareRequestFn: PrepareRequestFn<Requirements> | undefined;
-}): Effect.Effect<HttpClientRequest.HttpClientRequest, unknown, Requirements>;

package/dist/client/route-context.d.ts

@@ -1,31 +0,0 @@
-import { Option } from "effect";
-import { Atom } from "effect/unstable/reactivity";
-import type { ClientLoaderData, ClientLoaderState, ClientLoaderRoutePattern, LoaderData, LoaderRoutePattern, RouteMatch, RoutePattern } from "./contracts.ts";
-import type { RouteEntry } from "./state.ts";
-export declare const ROUTE_CONTEXT: unique symbol;
-export type RouteContextMatch = {
-    readonly pattern: string;
-    readonly params: Readonly<Record<string, string>>;
-    readonly splatValues: ReadonlyArray<string>;
-    readonly input: unknown;
-};
-export type RouteContext<Pattern extends string> = {
-    readonly [ROUTE_CONTEXT]: {
-        readonly pattern: Pattern;
-        readonly index: number;
-        readonly loaderDataAtom: Atom.Atom<unknown>;
-        readonly clientLoaderDataAtom: Atom.Atom<unknown>;
-        readonly matchAtom: Atom.Atom<RouteContextMatch>;
-    };
-};
-/** The route context of a view mounted at `index` for `entry`; its atoms follow that position while it holds the entry's pattern. */
-export declare function createRouteContext(index: number, entry: RouteEntry): RouteContext<string>;
-/** A stable native atom describing one pattern's committed server-loader data. */
-export declare function getLoaderDataAtom<Pattern extends LoaderRoutePattern>(context: RouteContext<Pattern>): Atom.Atom<LoaderData<Pattern>>;
-export declare function getLoaderDataAtom<Pattern extends LoaderRoutePattern>(pattern: Pattern): Atom.Atom<Option.Option<LoaderData<Pattern>>>;
-/** A view reads its loaded value; a pattern read includes absence and failure states. */
-export declare function getClientLoaderDataAtom<Pattern extends ClientLoaderRoutePattern>(context: RouteContext<Pattern>): Atom.Atom<ClientLoaderData<Pattern>>;
-export declare function getClientLoaderDataAtom<Pattern extends ClientLoaderRoutePattern>(pattern: Pattern): Atom.Atom<Option.Option<ClientLoaderState<Pattern>>>;
-/** A stable native atom describing one pattern's committed match facts. */
-export declare function getRouteMatchAtom<Pattern extends RoutePattern>(context: RouteContext<Pattern>): Atom.Atom<RouteMatch<Pattern>>;
-export declare function getRouteMatchAtom<Pattern extends RoutePattern>(pattern: Pattern): Atom.Atom<Option.Option<RouteMatch<Pattern>>>;

package/dist/client/route-matching.d.ts

@@ -1,22 +0,0 @@
-import { type CompiledNestedPattern } from "@vorma/primitives/matcher";
-import { Result } from "effect";
-import type { SearchContractDocument } from "../universal/protocol-schemas.ts";
-import { type SearchParamsError } from "../universal/search-parse.ts";
-export type LearnedMatch<Value> = {
-    readonly value: Value;
-    readonly params: Readonly<Record<string, string>>;
-    readonly splatValues: ReadonlyArray<string>;
-};
-export type LearnedMatcher<Value> = {
-    /** The registrations a canonical path matches completely, outermost to innermost; null when it matches none, or a capture does not decode. */
-    readonly matchPath: (path: string) => ReadonlyArray<LearnedMatch<Value>> | null;
-};
-export declare function createLearnedMatcher<Value>(registrations: ReadonlyArray<{
-    readonly pattern: CompiledNestedPattern;
-    readonly value: Value;
-}>): LearnedMatcher<Value>;
-/** Parses a destination's search through the decoded contract structure, without validating its checks. */
-export declare function parseSearch(input: {
-    readonly document: SearchContractDocument;
-    readonly searchParams: URLSearchParams;
-}): Result.Result<unknown, SearchParamsError>;

package/dist/client/route-synchronization.d.ts

@@ -1,30 +0,0 @@
-import { Effect, Result, Stream, type Duration } from "effect";
-import type { RoutePattern, RouteTarget } from "./contracts.ts";
-import { NavigationError, type InputError } from "./errors.ts";
-import { ClientCoordinator, type ClientCoordinatorService } from "./runtime.ts";
-import type { NavigationOptions } from "./types.ts";
-export type RouteSynchronizationOptions<Pattern extends RoutePattern = RoutePattern, Error = never, Requirements = never> = {
-    readonly targets: Stream.Stream<RouteTarget<Pattern>, Error, Requirements>;
-    readonly debounceDelay?: Duration.Input;
-    readonly replace?: NavigationOptions["replace"];
-    readonly scrollToTop?: NavigationOptions["scrollToTop"];
-    readonly scrollToFragment?: NavigationOptions["scrollToFragment"];
-    readonly skipWorkIndicator?: boolean;
-};
-type ResolvedSynchronizationTarget = {
-    readonly href: string;
-    readonly navigationOptions: NavigationOptions;
-};
-export declare function runSynchronizationTarget(input: {
-    readonly coordinator: ClientCoordinatorService;
-    readonly target: ResolvedSynchronizationTarget;
-    readonly debounceDelay: Duration.Input | undefined;
-}): Effect.Effect<void, NavigationError>;
-export declare function readSynchronizationTarget(input: {
-    readonly coordinator: ClientCoordinatorService;
-    readonly href: Result.Result<string, InputError>;
-    readonly options: Pick<RouteSynchronizationOptions, "replace" | "scrollToTop" | "scrollToFragment" | "skipWorkIndicator">;
-}): Effect.Effect<ResolvedSynchronizationTarget, NavigationError>;
-/** Keeps a route synchronized with the latest target from a native Stream. */
-export declare function synchronizeRoute<Pattern extends RoutePattern, Error = never, Requirements = never>(input: RouteSynchronizationOptions<Pattern, Error, Requirements>): Effect.Effect<void, Error | NavigationError, Requirements | ClientCoordinator>;
-export {};

package/dist/client/route-url.d.ts

@@ -1,5 +0,0 @@
-import { Result } from "effect";
-import type { NavigationTargetInput } from "./contracts.ts";
-import { InputError } from "./errors.ts";
-/** Returns a raw href unchanged or encodes a typed destination as an origin-relative URL. */
-export declare function toHref(input: NavigationTargetInput): Result.Result<string, InputError>;

package/dist/client/runtime.d.ts

@@ -1,82 +0,0 @@
-import { Context, Effect, type Fiber, type Stream } from "effect";
-import type { HttpClient } from "effect/unstable/http";
-import { Atom, type AtomRegistry, type Reactivity } from "effect/unstable/reactivity";
-import type { EndpointOperations } from "./endpoints.ts";
-import type { ClientApplicationContracts } from "./index.ts";
-import type { NavigationOwner } from "./navigation.ts";
-import type { PrefetchOwner } from "./prefetch.ts";
-import type { QueryOwner } from "./queries.ts";
-import type { ClientEvent } from "./types.ts";
-export type ClientUnavailableError = {
-    readonly _tag: "ClientUnavailableError";
-};
-export declare const CLIENT_UNAVAILABLE_ERROR: ClientUnavailableError;
-declare const CLIENT_COORDINATOR: unique symbol;
-/** The mounted browser application's Effect requirement. */
-export type ClientCoordinator = {
-    readonly [CLIENT_COORDINATOR]: true;
-};
-export type ClientCoordinatorService = {
-    readonly trackWork: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-    readonly registry: AtomRegistry.AtomRegistry;
-    readonly events: Stream.Stream<ClientEvent>;
-    readonly publishEvent: (event: ClientEvent) => void;
-    readonly navigation: NavigationOwner;
-    readonly prefetch: PrefetchOwner;
-    readonly endpoints: EndpointOperations;
-    readonly queries: QueryOwner;
-    /** Forks application-owned work into the application scope. */
-    readonly fork: <A, E>(effect: Effect.Effect<A, E>) => Fiber.Fiber<A, E>;
-    /** Admits a render failure into route error metadata when it belongs to the committed render. */
-    readonly reportRenderFailure: (input: {
-        readonly index: number | undefined;
-        readonly pattern: string | undefined;
-        readonly revision: number;
-        readonly error: unknown;
-    }) => void;
-};
-export declare const ClientCoordinator: Context.Service<ClientCoordinator, ClientCoordinatorService>;
-/** Services acquired by the browser application and available to client computations. */
-export type FrameworkClientServices = ClientCoordinator | AtomRegistry.AtomRegistry | Reactivity.Reactivity | HttpClient.HttpClient;
-type RegisteredClientServices = ClientApplicationContracts extends {
-    readonly clientOnlyServices: {
-        readonly services: infer ClientOnlyServices;
-        readonly error: infer ClientOnlyServicesError;
-    };
-    readonly universalServices: {
-        readonly services: infer UniversalServices;
-        readonly error: infer UniversalServicesError;
-    };
-} ? {
-    readonly services: FrameworkClientServices | ClientOnlyServices | UniversalServices;
-    readonly error: ClientUnavailableError | ClientOnlyServicesError | UniversalServicesError;
-} : {
-    readonly services: FrameworkClientServices;
-    readonly error: ClientUnavailableError;
-};
-type RegisteredUniversalServices = ClientApplicationContracts extends {
-    readonly universalServices: {
-        readonly services: infer Services;
-    };
-} ? Services : never;
-type RegisteredUniversalServicesError = ClientApplicationContracts extends {
-    readonly universalServices: {
-        readonly error: infer Error;
-    };
-} ? Error | ClientUnavailableError : ClientUnavailableError;
-/** The contexts one mounted application assembled once; both runtimes read them. */
-export type ApplicationContexts = {
-    readonly universal: Context.Context<never>;
-    readonly client: Context.Context<never>;
-};
-export declare function publishApplicationContexts(input: {
-    readonly registry: AtomRegistry.AtomRegistry;
-    readonly contexts: ApplicationContexts;
-}): void;
-/** Browser operations and both service groups. Asynchronous computations stay Initial before boot. */
-export declare const clientRuntime: Atom.AtomRuntime<RegisteredClientServices["services"], RegisteredClientServices["error"]>;
-/** Provides only the application's universal service group. */
-export declare const universalRuntime: Atom.AtomRuntime<RegisteredUniversalServices, RegisteredUniversalServicesError>;
-/** Runs an Effect with the mounted application's client context. */
-export declare function provideClientContext<A, E>(contexts: ApplicationContexts, effect: Effect.Effect<A, E, unknown>): Effect.Effect<A, E>;
-export {};

package/dist/client/scroll.d.ts

@@ -1,16 +0,0 @@
-import { Result } from "effect";
-/** A target scroll: a coordinate pair, or a fragment whose element scrolls into view. */
-export type ScrollTarget = {
-    readonly x: number;
-    readonly y: number;
-} | {
-    readonly hash: string;
-};
-export type ScrollPosition = {
-    readonly x: number;
-    readonly y: number;
-};
-export declare function readScrollPosition(): ScrollPosition;
-export declare function normalizeFragment(hash: string): string;
-/** Applies the target through the browser's scroll calls, the one platform boundary here; a failure comes back as a value. */
-export declare function applyScroll(target: ScrollTarget): Result.Result<void, unknown>;

package/dist/client/services.d.ts

@@ -1,34 +0,0 @@
-import { Context, Effect, Option, RcMap, Scope } from "effect";
-import { Atom } from "effect/unstable/reactivity";
-import { type ApplicationContexts, type ClientCoordinator } from "./runtime.ts";
-import type { CachedRouteEntry, RouteEntry } from "./state.ts";
-import type { ViewDefinition } from "./view-definition.ts";
-/** Identifies one activation; a new key means a new activation. */
-export type ActivationKey = {
-    readonly pattern: string;
-    readonly view: ViewDefinition;
-};
-export type RouteActivation = {
-    readonly key: ActivationKey;
-    readonly client: Context.Context<ClientCoordinator>;
-    readonly universal: Context.Context<never>;
-    readonly clientRuntime: Atom.AtomRuntime<ClientCoordinator, never>;
-    readonly universalRuntime: Atom.AtomRuntime<never, never>;
-};
-/** The activation a route-local computation runs under; a mutation holds it until settlement. */
-export declare const CurrentActivation: Context.Service<ActivationKey, ActivationKey>;
-export type ActivationMap = RcMap.RcMap<ActivationKey, RouteActivation, unknown>;
-export declare function declaresServices(view: ViewDefinition): boolean;
-/** Builds the activation map in the application scope. */
-export declare function createActivationMap(getApplicationContextsFn: () => Option.Option<ApplicationContexts>): Effect.Effect<ActivationMap, never, Scope.Scope>;
-/**
- * Acquires every entry's activation in `scope`. A live preparation keeps its
- * hold until this scope acquires it. A cached entry contains only the key;
- * re-entry builds a new activation when no owner retains that key.
- */
-export declare function acquireActivations(activations: ActivationMap, input: {
-    readonly entries: ReadonlyArray<RouteEntry | CachedRouteEntry>;
-    readonly scope: Scope.Scope;
-}): Effect.Effect<ReadonlyArray<RouteEntry>, unknown>;
-/** Omits acquired contexts and runtimes from a reusable entry. */
-export declare function toCachedRouteEntry(entry: RouteEntry): CachedRouteEntry;

package/dist/client/state.d.ts

@@ -1,102 +0,0 @@
-import { Option, type Deferred, type Scope } from "effect";
-import { AsyncResult, Atom } from "effect/unstable/reactivity";
-import type { ScrollIntent } from "./commit.ts";
-import type { NavigationError, RevalidationError } from "./errors.ts";
-import type { HeadSections } from "./head.ts";
-import type { ActivationKey, RouteActivation } from "./services.ts";
-import type { BuildMismatch, ClientLifecycle, RouteErrorSource, NavigationResult, OperationId, OperationState, PendingNavigation, RevalidationResult } from "./types.ts";
-import type { ViewDefinition } from "./view-definition.ts";
-export type RouteErrorState = {
-    readonly index: number;
-    readonly pattern: string | undefined;
-    readonly source: RouteErrorSource;
-    readonly error: unknown;
-};
-/** One matched route's facts, kept together from preparation through commit. */
-export type RouteEntry = {
-    readonly pattern: string;
-    readonly params: Readonly<Record<string, string>>;
-    readonly splatValues: ReadonlyArray<string>;
-    /** The decoded search input; `undefined` when the route has none or decoding failed. */
-    readonly input: unknown;
-    /** The view module's definition; `undefined` for a server-only route or a missing module. */
-    readonly view: ViewDefinition | undefined;
-    /** The decoded server loader output; `undefined` when unavailable. */
-    readonly loaderData: unknown;
-    readonly clientLoaderData: AsyncResult.AsyncResult<unknown, unknown>;
-    /** The route's service activation, held by its owner's scope; `undefined` when the view declares no local services. */
-    readonly activation: RouteActivation | undefined;
-};
-/** Reusable route data identifies an activation without retaining its acquired services. */
-export type CachedRouteEntry = Omit<RouteEntry, "activation"> & {
-    readonly activationKey: ActivationKey | undefined;
-};
-/** The committed frame: what the screen shows and what the public route state describes. */
-export type Frame = {
-    readonly href: string;
-    readonly historyState: unknown;
-    /** The history entry's key; absent when the entry predates the client. */
-    readonly key: string | undefined;
-    readonly clientBuildId: string;
-    readonly entries: ReadonlyArray<RouteEntry>;
-    readonly error: RouteErrorState | null;
-    readonly head: HeadSections;
-    readonly cssBundles: ReadonlyArray<string>;
-    /** Holds the entries' activations; closed when a later frame replaces it. */
-    readonly scope: Scope.Closeable;
-    readonly revision: number;
-    readonly committedAt: number;
-    /** Applied by the renderer once the destination view exists in the DOM. */
-    readonly scrollIntent: ScrollIntent | undefined;
-};
-export type NavigationFacts = {
-    readonly pending: PendingNavigation | null;
-    readonly latest: AsyncResult.AsyncResult<NavigationResult, NavigationError>;
-};
-export type FreshnessDemand = {
-    readonly afterSequence: number;
-    readonly skipWorkIndicator: boolean;
-    /** A trigger registered while an attempt was running; a failed attempt then runs again. */
-    readonly renewed: boolean;
-    /** The query computations that evaluated for the demand's epoch and were not released; each must acknowledge. */
-    readonly expectedQueries: ReadonlySet<string>;
-    /** Expected queries that acknowledged, by the sequence of the read they acknowledged with. */
-    readonly acknowledgedQueries: ReadonlyMap<string, number>;
-    /** The sequence of the qualifying route read, once one committed. */
-    readonly routeReadSequence: number | null;
-    readonly waiters: ReadonlyArray<Deferred.Deferred<RevalidationResult, RevalidationError>>;
-};
-export type FreshnessAttempt = {
-    /** The demand sequence this attempt's read covers; `null` before any attempt. */
-    readonly coveredSequence: number | null;
-    /** `retrying`: the last read failed and the application's schedule holds the next one. */
-    readonly phase: "idle" | "running" | "retrying" | "failed";
-    readonly skipWorkIndicator: boolean;
-    /** The waiter batch captured when the attempt started; a failure settles only these. */
-    readonly waiters: ReadonlyArray<Deferred.Deferred<RevalidationResult, RevalidationError>>;
-    readonly latest: AsyncResult.AsyncResult<RevalidationResult, RevalidationError>;
-};
-export type FreshnessFacts = {
-    readonly demand: FreshnessDemand | null;
-    readonly attempt: FreshnessAttempt;
-    /** Advances with every registered demand; active queries recompute on it. */
-    readonly epoch: number;
-};
-export type PrefetchFacts = {
-    readonly href: string;
-    readonly skipWorkIndicator: boolean;
-};
-export type ClientState = {
-    readonly lifecycle: ClientLifecycle;
-    readonly frame: Frame | null;
-    readonly navigation: NavigationFacts;
-    readonly freshness: FreshnessFacts;
-    readonly operations: ReadonlyMap<OperationId, OperationState>;
-    readonly prefetch: ReadonlyMap<string, PrefetchFacts>;
-    readonly buildMismatch: Option.Option<BuildMismatch>;
-    readonly generation: number;
-    readonly sequence: number;
-};
-export declare const INITIAL_CLIENT_STATE: ClientState;
-/** Registry-local state; private to the package. Public atoms are projections. */
-export declare const clientStateAtom: Atom.Writable<ClientState, ClientState>;

package/dist/client/static-assets.d.ts

@@ -1,3 +0,0 @@
-import { Effect, type Scope } from "effect";
-/** Adds shared, scoped resource hints without awaiting resource loading. */
-export declare function preloadStaticAssets(urls: ReadonlyArray<string>): Effect.Effect<void, never, Scope.Scope>;

package/dist/client/stylesheets.d.ts

@@ -1,7 +0,0 @@
-import { Effect, type Scope } from "effect";
-/** Reads the stylesheet bundles that the initial document applied. */
-export declare function readDocumentStylesheets(): ReadonlyArray<string>;
-/** Starts managed CSS preloads and waits for every load or error without applying destination styles. */
-export declare function prepareStylesheets(bundles: ReadonlyArray<string>): Effect.Effect<void, never, Scope.Scope>;
-/** Publishes managed styles after their preload attempts have settled. */
-export declare function applyStylesheets(bundles: ReadonlyArray<string>): void;

package/dist/client/transport-type-entries.d.ts

@@ -1,2 +0,0 @@
-/** The Effect data types that occur in this application's contracts. */
-export declare const CLIENT_TRANSPORT_TYPE_ENTRIES: readonly TransportTypeEntry[];

package/dist/client/types.d.ts

@@ -1,152 +0,0 @@
-import type { Brand, Cause, Exit, Option } from "effect";
-import type { AsyncResult } from "effect/unstable/reactivity";
-import type { NavigationError, RevalidationError } from "./errors.ts";
-/** An opaque identity Vorma assigns to one endpoint operation execution. */
-export type OperationId = string & Brand.Brand<"VormaOperationId">;
-/** Public server-failure presentation fields. */
-export type PublicRouteError = {
-    readonly status: number;
-    readonly clientMessage: string;
-};
-export type RouteMatchSummary = {
-    readonly pattern: string;
-    readonly params: Readonly<Record<string, string>>;
-    readonly splatValues: ReadonlyArray<string>;
-};
-/** Server failures contain public fields only; browser failures retain their native Effect cause. */
-export type BoundaryError = PublicRouteError & ({
-    readonly source: "serverLoader";
-} | {
-    readonly source: "clientLoader" | "render" | "boot";
-    readonly cause: Cause.Cause<unknown>;
-});
-export type RouteErrorSource = Exclude<BoundaryError["source"], "boot">;
-export type RouteError = BoundaryError & {
-    /** Absent when the server does not disclose the failed route. */
-    readonly pattern: string | undefined;
-    readonly source: RouteErrorSource;
-};
-/** The committed location and matched-route metadata. */
-export type RouteState = {
-    readonly href: string;
-    readonly historyState: Option.Option<unknown>;
-    readonly matches: ReadonlyArray<RouteMatchSummary>;
-    readonly error: Option.Option<RouteError>;
-};
-export type RouteUpdateReason = "boot" | "navigation" | "popstate" | "hmr" | "revalidation";
-export type NavigationSource = "navigate" | "popstate" | "redirect";
-export type NavigationResult = {
-    readonly _tag: "Committed";
-    readonly href: string;
-} | {
-    readonly _tag: "Unchanged";
-    readonly href: string;
-} | {
-    readonly _tag: "Superseded";
-} | {
-    readonly _tag: "DocumentNavigation";
-    readonly href: string;
-};
-export type NavigationOptions = {
-    readonly replace?: boolean;
-    /** A URL fragment still scrolls to its target when false. */
-    readonly scrollToTop?: boolean;
-    /** False disables fragment scrolling independently of scrolling to the top. */
-    readonly scrollToFragment?: boolean;
-    readonly historyState?: unknown;
-    readonly skipWorkIndicator?: boolean;
-};
-export type PendingNavigation = {
-    readonly href: string;
-    readonly source: NavigationSource;
-    readonly skipWorkIndicator: boolean;
-};
-export type NavigationState = {
-    readonly pending: Option.Option<PendingNavigation>;
-    readonly latestAttempt: AsyncResult.AsyncResult<NavigationResult, NavigationError>;
-};
-export type RevalidationResult = {
-    readonly _tag: "Refreshed";
-} | {
-    readonly _tag: "Skipped";
-} | {
-    readonly _tag: "DocumentNavigation";
-    readonly href: string;
-};
-export type PendingRevalidation = {
-    readonly phase: "scheduled" | "running";
-    readonly skipWorkIndicator: boolean;
-};
-export type RevalidationState = {
-    readonly requiresRevalidation: boolean;
-    readonly pending: Option.Option<PendingRevalidation>;
-    readonly latestAttempt: AsyncResult.AsyncResult<RevalidationResult, RevalidationError>;
-};
-export type OperationKind = "Query" | "Mutation";
-export type OperationPhase = "preparing" | "dispatched" | "settled";
-/** Public lifecycle facts of one endpoint operation; bodies and credentials stay private. */
-export type OperationState = {
-    readonly operationId: OperationId;
-    readonly kind: OperationKind;
-    readonly request: {
-        readonly method: string;
-        readonly pattern: string;
-        readonly href: Option.Option<string>;
-    };
-    readonly phase: OperationPhase;
-    readonly skipWorkIndicator: boolean;
-    readonly skipAutoRevalidate: boolean;
-};
-export type PendingPrefetch = {
-    readonly href: string;
-    readonly phase: "preparing";
-    readonly skipWorkIndicator: boolean;
-};
-export type WorkState = {
-    readonly navigation: Option.Option<PendingNavigation>;
-    readonly revalidation: Option.Option<PendingRevalidation>;
-    readonly prefetches: ReadonlyArray<PendingPrefetch>;
-    readonly operations: ReadonlyArray<OperationState>;
-};
-export type RequestKind = "Navigation" | "Prefetch" | "Revalidation" | "Query" | "Mutation" | "Stream";
-export type BuildMismatch = {
-    readonly clientBuildId: string;
-    /** The build the server named; `undefined` when the refusing response did not name one. */
-    readonly serverBuildId: string | undefined;
-    readonly requestedHref: string;
-    readonly requestKind: RequestKind;
-    readonly status: number;
-};
-export type FailureSource = "hmr" | "navigation" | "revalidation" | "clientLoader" | "clientLoaderEligibility" | "render" | "browserProgram";
-export type ClientEvent = {
-    readonly _tag: "RouteCommitted";
-    readonly previous: Option.Option<RouteState>;
-    readonly current: RouteState;
-    readonly reason: RouteUpdateReason;
-} | {
-    readonly _tag: "OperationSettled";
-    readonly operation: OperationState;
-    readonly outcome: Exit.Exit<unknown, unknown>;
-} | {
-    readonly _tag: "BuildMismatchDetected";
-    readonly mismatch: BuildMismatch;
-} | {
-    readonly _tag: "FailureReported";
-    readonly source: FailureSource;
-    readonly cause: Cause.Cause<unknown>;
-};
-export type ClientBootError = {
-    readonly _tag: "ClientBootError";
-    readonly message: string;
-    readonly cause?: unknown;
-};
-export type ClientLifecycle = {
-    readonly _tag: "PreBoot";
-} | {
-    readonly _tag: "BootFailed";
-    readonly error: ClientBootError;
-} | {
-    readonly _tag: "Ready";
-} | {
-    readonly _tag: "Disposed";
-};