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

package/dist/client/head.d.ts

@@ -1,14 +0,0 @@
-import { Result } from "effect";
-import type { HeadElementWire } from "../universal/protocol-schemas.ts";
-export type HeadSections = {
-    readonly title: HeadElementWire | undefined;
-    readonly meta: ReadonlyArray<HeadElementWire>;
-    readonly rest: ReadonlyArray<HeadElementWire>;
-};
-export type HeadReconciliationError = {
-    readonly _tag: "HeadReconciliationError";
-    readonly message: string;
-};
-export declare function applyHead(sections: HeadSections): Result.Result<void, HeadReconciliationError>;
-/** Reads the server-rendered head state from the three managed regions. */
-export declare function readDocumentHead(): Result.Result<HeadSections, HeadReconciliationError>;

package/dist/client/history.d.ts

@@ -1,25 +0,0 @@
-import { Result } from "effect";
-import type { ScrollPosition } from "./scroll.ts";
-export type BrowserPosition = {
-    readonly href: string;
-    readonly userState: unknown;
-    readonly key: string | undefined;
-};
-export type HistoryStateError = {
-    readonly _tag: "HistoryStateError";
-    readonly message: string;
-    readonly cause: unknown;
-};
-export declare function createEntryKey(): string;
-/** Reads native user state and Vorma's entry key without imposing a user-data codec. */
-export declare function readBrowserPosition(): Result.Result<BrowserPosition, HistoryStateError>;
-/** Writes a new or replaced history entry and returns the position it produced. */
-export declare function writeBrowserPosition(input: {
-    readonly href: string;
-    readonly replace: boolean;
-    readonly userState: unknown;
-    readonly key: string;
-}): Result.Result<BrowserPosition, HistoryStateError>;
-/** Remembers the scroll position of the entry `key` names. */
-export declare function rememberScroll(key: string, scroll: ScrollPosition): void;
-export declare function recallScroll(key: string): ScrollPosition | undefined;

package/dist/client/index.d.ts

@@ -1,80 +0,0 @@
-import { Effect, Result, Stream } from "effect";
-import type { Atom } from "effect/unstable/reactivity";
-import type { MissingGeneratedApplicationKey } from "../universal/generated-types.ts";
-import type { EndpointCallFailure, EndpointCallOutput, MutationEndpointCallInput, NavigationTargetInput, QueryEndpointCallInput } from "./contracts.ts";
-import type { EndpointFrameworkError, MutationSettlement } from "./endpoints.ts";
-import { InputError, NavigationError, PrefetchError, type QueryRedirected, type RevalidationError } from "./errors.ts";
-import { type LinkMatchRules, type LinkState } from "./links.ts";
-import type { QueryEndpointOutput } from "./queries.ts";
-import { ClientCoordinator } from "./runtime.ts";
-import type { ClientEvent, NavigationOptions, NavigationResult, RevalidationResult } from "./types.ts";
-export type { WorkIndicatorOptions } from "./work-indicator.ts";
-/** Application contract catalogue supplied by Vorma's generated declarations. */
-export interface ClientApplicationContracts {
-}
-type RegisteredAssetKey = ClientApplicationContracts extends {
-    readonly assets: infer Key extends string;
-} ? Key | `/${Key}` : MissingGeneratedApplicationKey;
-/**
- * The hashed URL of a public asset, typed by the generated asset keys. The
- * build requires a string literal argument and replaces each call with that
- * asset's hashed URL. This function body exists so that imports and re-exports
- * of `getPublicUrl` are valid JavaScript; a correct client build replaces every
- * call, and the bundler then removes the unused function from the output.
- */
-export declare function getPublicUrl(_key: RegisteredAssetKey): string;
-export type { BuildMismatch, ClientBootError, ClientEvent, ClientLifecycle, FailureSource, NavigationOptions, NavigationResult, NavigationSource, NavigationState, OperationId, OperationKind, OperationPhase, OperationState, PendingNavigation, PendingPrefetch, PendingRevalidation, PublicRouteError, BoundaryError, RequestKind, RevalidationResult, RevalidationState, RouteError, RouteErrorSource, RouteMatchSummary, RouteState, RouteUpdateReason, WorkState, } from "./types.ts";
-export type { AnyRouteMatch, ClientLoaderData, ClientLoaderState, ClientLoaderRoutePattern, EndpointCallFailure, EndpointCallOutput, EndpointRequestOptions, LoaderData, LoaderRoutePattern, MutationEndpointCallInput, QueryEndpointCallInput, RawHrefTarget, RouteInput, RouteMatch, RoutePattern, RouteTarget, RouteUrlInput, } from "./contracts.ts";
-export type { TransportTypeEntry } from "../universal/value-transport.ts";
-export { optionTransportType } from "../universal/transport-types/option.ts";
-export { redactedTransportType } from "../universal/transport-types/redacted.ts";
-export { chunkTransportType } from "../universal/transport-types/chunk.ts";
-export { durationTransportType } from "../universal/transport-types/duration.ts";
-export { bigDecimalTransportType } from "../universal/transport-types/big-decimal.ts";
-export { dateTimeUtcTransportType } from "../universal/transport-types/date-time-utc.ts";
-export { dateTimeZonedTransportType } from "../universal/transport-types/date-time-zoned.ts";
-export { hashMapTransportType } from "../universal/transport-types/hash-map.ts";
-export { hashSetTransportType } from "../universal/transport-types/hash-set.ts";
-export type { ClientRequestContext, PrepareRequestFn } from "./request.ts";
-export { synchronizeRoute, type RouteSynchronizationOptions, } from "./route-synchronization.ts";
-export { toHref } from "./route-url.ts";
-export type { EndpointFrameworkError, MutationSettlement, ResponseMetadata, QueryResponse, } from "./endpoints.ts";
-export type { ClientLoaderTrigger } from "./client-loaders.ts";
-export { createQueryAtom, type QueryAtom, type QueryEndpointOutput, } from "./queries.ts";
-export type { ClientLoaderContext } from "./contracts.ts";
-export { getClientLoaderDataAtom, getLoaderDataAtom, getRouteMatchAtom, type RouteContext, } from "./route-context.ts";
-export { type LinkMatchRules, type LinkState } from "./links.ts";
-export { BuildMismatchError, HandlerError, CancelledByDedupeKeyError, InputError, NavigationError, PrefetchError, QueryRedirected, RevalidationError, TransportError, type QueryNavigation, } from "./errors.ts";
-export { type ClientCoordinator, clientRuntime, universalRuntime, type ClientUnavailableError, } from "./runtime.ts";
-export declare function getRouteStateAtom(): Atom.Atom<import("effect/Option").Option<import("./types.ts").RouteState>>;
-export declare function getNavigationStateAtom(): Atom.Atom<import("./types.ts").NavigationState>;
-export declare function getRevalidationStateAtom(): Atom.Atom<import("./types.ts").RevalidationState>;
-export declare function getWorkStateAtom(): Atom.Atom<import("./types.ts").WorkState>;
-/** Includes an Effect in the work indicator until it succeeds, fails, or is interrupted. */
-export declare function trackWork<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R | ClientCoordinator>;
-export declare function getWorkIndicatorActiveAtom(): Atom.Atom<boolean>;
-export declare function getBuildMismatchAtom(): Atom.Atom<import("effect/Option").Option<import("./types.ts").BuildMismatch>>;
-/** Native atom retention owns the last observed settlement after active work retires. */
-export { getOperationStateAtom } from "./projections.ts";
-/** Subscribe to each framework event from this mounted application's lifetime. */
-export declare function observeClientEvents(): Stream.Stream<ClientEvent, never, ClientCoordinator>;
-/** Starts a navigation and observes its typed outcome. */
-export declare function navigate(input: NavigationTargetInput & NavigationOptions): Effect.Effect<NavigationResult, NavigationError, ClientCoordinator>;
-/** Prepares a destination for promotion while the Effect runs; readiness completes it. */
-export declare function prefetch(input: NavigationTargetInput & {
-    readonly skipWorkIndicator?: boolean;
-}): Effect.Effect<void, PrefetchError, ClientCoordinator>;
-/** The active and pending facts of a link target under its match rules; a target that does not encode has no link state. */
-export declare function getLinkStateAtom(input: NavigationTargetInput & {
-    readonly matchRules?: LinkMatchRules;
-}): Result.Result<Atom.Atom<LinkState>, InputError>;
-/** Retires every value of the current session, refreshes the committed route and active queries, and awaits the result. */
-export declare function invalidateClientData(): Effect.Effect<RevalidationResult, RevalidationError, ClientCoordinator>;
-/** Registers fresh-data demand for the committed route and awaits its qualifying result. */
-export declare function revalidate(options?: {
-    readonly skipWorkIndicator?: boolean;
-}): Effect.Effect<RevalidationResult, RevalidationError, ClientCoordinator>;
-/** Returns decoded query data and response metadata; a redirect surfaces as a typed navigation handoff. */
-export declare function queryEndpoint<const Input extends QueryEndpointCallInput>(input: Input): Effect.Effect<QueryEndpointOutput<Input>, EndpointCallFailure<Input, EndpointFrameworkError | QueryRedirected>, ClientCoordinator>;
-/** Observes an application-owned mutation settlement and its scheduled refresh. */
-export declare function mutateEndpoint<const Input extends MutationEndpointCallInput>(input: Input): Effect.Effect<MutationSettlement<EndpointCallOutput<Input>>, EndpointCallFailure<Input, EndpointFrameworkError>, ClientCoordinator>;

package/dist/client/index.js

@@ -1,150 +0,0 @@
-import { A as routeStateAtom, B as RevalidationError, F as HandlerError, I as InputError, L as NavigationError, N as BuildMismatchError, O as refreshEpochAtom, P as CancelledByDedupeKeyError, R as PrefetchError, S as buildMismatchAtom, T as navigationStateAtom, V as TransportError, d as ClientCoordinator, f as clientRuntime, g as toHref, h as universalRuntime, i as getRouteMatchAtom, j as workStateAtom, k as revalidationStateAtom, l as workIndicatorActiveAtom, n as getClientLoaderDataAtom, r as getLoaderDataAtom, s as synchronizeRoute, w as getOperationStateAtom, x as getLinkStateAtomFor, z as QueryRedirected } from "../route-context-CtY_9U_W.js";
-import { a as bigDecimalTransportType, c as redactedTransportType, i as dateTimeUtcTransportType, l as optionTransportType, n as hashMapTransportType, o as durationTransportType, r as dateTimeZonedTransportType, s as chunkTransportType, t as hashSetTransportType } from "../hash-set-BPx3iXec.js";
-import { Cause, Context, Effect, Exit, Option, Result, Stream } from "effect";
-import { AsyncResult, Atom } from "effect/unstable/reactivity";
-//#region src/client/queries.ts
-function createQueryAtom(input) {
-	const id = crypto.randomUUID();
-	const requestAtom = Atom.isAtom(input.request) ? input.request : Atom.make(Option.some(input.request));
-	const reading = input.runtime.atom((get) => {
-		const request = get(requestAtom);
-		get(refreshEpochAtom);
-		const computation = {
-			id,
-			token: Symbol("vorma/query-computation")
-		};
-		const runtime = get(input.runtime);
-		const coordinatorNow = AsyncResult.isSuccess(runtime) ? Context.getOption(runtime.value, ClientCoordinator) : Option.none();
-		if (Option.isSome(coordinatorNow) && Option.isSome(request)) coordinatorNow.value.queries.expect(computation);
-		return Effect.gen(function* () {
-			if (Option.isNone(request)) return yield* Effect.never;
-			const coordinator = yield* ClientCoordinator;
-			yield* Effect.addFinalizer(() => {
-				return Effect.sync(() => coordinator.queries.release(computation));
-			});
-			let dispatched;
-			const exit = yield* Effect.exit(coordinator.endpoints.read(request.value, (facts) => {
-				dispatched = facts;
-			}));
-			if (Exit.isSuccess(exit) || !Cause.hasInterruptsOnly(exit.cause)) coordinator.queries.acknowledge({
-				id,
-				dispatched,
-				success: Exit.isSuccess(exit)
-			});
-			return Exit.isSuccess(exit) ? exit.value : yield* Effect.failCause(exit.cause);
-		});
-	});
-	return Atom.readable((get) => {
-		return Option.isNone(get(requestAtom)) ? AsyncResult.initial() : get(reading);
-	}, (refresh) => refresh(reading));
-}
-//#endregion
-//#region src/client/index.ts
-/**
-* The hashed URL of a public asset, typed by the generated asset keys. The
-* build requires a string literal argument and replaces each call with that
-* asset's hashed URL. This function body exists so that imports and re-exports
-* of `getPublicUrl` are valid JavaScript; a correct client build replaces every
-* call, and the bundler then removes the unused function from the output.
-*/
-function getPublicUrl(_key) {
-	throw new Error("Vorma's client build did not replace getPublicUrl with a public asset URL");
-}
-function getRouteStateAtom() {
-	return routeStateAtom;
-}
-function getNavigationStateAtom() {
-	return navigationStateAtom;
-}
-function getRevalidationStateAtom() {
-	return revalidationStateAtom;
-}
-function getWorkStateAtom() {
-	return workStateAtom;
-}
-/** Includes an Effect in the work indicator until it succeeds, fails, or is interrupted. */
-function trackWork(effect) {
-	return Effect.flatMap(ClientCoordinator, (coordinator) => coordinator.trackWork(effect));
-}
-function getWorkIndicatorActiveAtom() {
-	return workIndicatorActiveAtom;
-}
-function getBuildMismatchAtom() {
-	return buildMismatchAtom;
-}
-/** Subscribe to each framework event from this mounted application's lifetime. */
-function observeClientEvents() {
-	return Stream.unwrap(Effect.map(ClientCoordinator, (coordinator) => coordinator.events));
-}
-/** Starts a navigation and observes its typed outcome. */
-function navigate(input) {
-	return Effect.flatMap(ClientCoordinator, (coordinator) => {
-		const href = toHref(input);
-		if (Result.isFailure(href)) return Effect.fail(new NavigationError({
-			stage: "target",
-			cause: Cause.fail(href.failure)
-		}));
-		const options = {
-			...input.replace === void 0 ? {} : { replace: input.replace },
-			...input.scrollToTop === void 0 ? {} : { scrollToTop: input.scrollToTop },
-			...input.scrollToFragment === void 0 ? {} : { scrollToFragment: input.scrollToFragment },
-			...input.historyState === void 0 ? {} : { historyState: input.historyState },
-			...input.skipWorkIndicator === void 0 ? {} : { skipWorkIndicator: input.skipWorkIndicator }
-		};
-		return coordinator.navigation.navigate(href.success, options);
-	});
-}
-/** Prepares a destination for promotion while the Effect runs; readiness completes it. */
-function prefetch(input) {
-	return Effect.flatMap(ClientCoordinator, (coordinator) => {
-		const href = toHref(input);
-		const url = Result.flatMap(href, (value) => {
-			return Result.try(() => new URL(value, window.location.href));
-		});
-		if (Result.isFailure(url)) return Effect.fail(new PrefetchError({
-			reason: "target",
-			cause: url.failure
-		}));
-		if (url.success.origin !== window.location.origin) return Effect.fail(new PrefetchError({
-			reason: "target",
-			cause: "A prefetch target must be on the application's origin"
-		}));
-		return coordinator.prefetch.awaitReadiness(url.success, { skipWorkIndicator: input.skipWorkIndicator === true });
-	});
-}
-/** The active and pending facts of a link target under its match rules; a target that does not encode has no link state. */
-function getLinkStateAtom(input) {
-	return Result.map(toHref(input), (href) => {
-		return getLinkStateAtomFor({
-			href,
-			pattern: input.pattern,
-			rules: input.matchRules
-		});
-	});
-}
-/** Retires every value of the current session, refreshes the committed route and active queries, and awaits the result. */
-function invalidateClientData() {
-	return Effect.flatMap(ClientCoordinator, (coordinator) => {
-		return coordinator.navigation.invalidate();
-	});
-}
-/** Registers fresh-data demand for the committed route and awaits its qualifying result. */
-function revalidate(options) {
-	return Effect.flatMap(ClientCoordinator, (coordinator) => {
-		return coordinator.navigation.revalidate({ skipWorkIndicator: options?.skipWorkIndicator === true });
-	});
-}
-/** Returns decoded query data and response metadata; a redirect surfaces as a typed navigation handoff. */
-function queryEndpoint(input) {
-	return Effect.flatMap(ClientCoordinator, (coordinator) => {
-		return coordinator.endpoints.query(input);
-	});
-}
-/** Observes an application-owned mutation settlement and its scheduled refresh. */
-function mutateEndpoint(input) {
-	return Effect.flatMap(ClientCoordinator, (coordinator) => {
-		return coordinator.endpoints.mutate(input);
-	});
-}
-//#endregion
-export { BuildMismatchError, CancelledByDedupeKeyError, HandlerError, InputError, NavigationError, PrefetchError, QueryRedirected, RevalidationError, TransportError, bigDecimalTransportType, chunkTransportType, clientRuntime, createQueryAtom, dateTimeUtcTransportType, dateTimeZonedTransportType, durationTransportType, getBuildMismatchAtom, getClientLoaderDataAtom, getLinkStateAtom, getLoaderDataAtom, getNavigationStateAtom, getOperationStateAtom, getPublicUrl, getRevalidationStateAtom, getRouteMatchAtom, getRouteStateAtom, getWorkIndicatorActiveAtom, getWorkStateAtom, hashMapTransportType, hashSetTransportType, invalidateClientData, mutateEndpoint, navigate, observeClientEvents, optionTransportType, prefetch, queryEndpoint, redactedTransportType, revalidate, synchronizeRoute, toHref, trackWork, universalRuntime };

package/dist/client/links.d.ts

@@ -1,48 +0,0 @@
-import { Atom } from "effect/unstable/reactivity";
-import type { ClientCoordinatorService } from "./runtime.ts";
-export type LinkMatchRules = {
-    readonly skip?: boolean;
-    readonly includeSearch?: boolean;
-    readonly includeHash?: boolean;
-};
-export type LinkState = {
-    readonly active: {
-        readonly exact: boolean;
-        readonly ancestor: boolean;
-    };
-    readonly pending: {
-        readonly exact: boolean;
-        readonly ancestor: boolean;
-    };
-};
-/** The active and pending facts of a resolved link target under its match rules. */
-export declare function getLinkStateAtomFor(input: {
-    readonly href: string;
-    readonly pattern: string | undefined;
-    readonly rules: LinkMatchRules | undefined;
-}): Atom.Atom<LinkState>;
-/** The subset of pointer event fields the click predicates inspect. */
-export type ClickFacts = {
-    readonly metaKey?: boolean;
-    readonly altKey?: boolean;
-    readonly ctrlKey?: boolean;
-    readonly shiftKey?: boolean;
-    readonly button?: number;
-};
-/** Whether a click may be intercepted: unmodified, primary, and targeting this browsing context. */
-export declare function allowsInterception(event: ClickFacts, targetAttribute: string | undefined): boolean;
-export type LinkIntent = {
-    /** Starts a prefetch observer after the supplied delay, or 100 ms when omitted. */
-    readonly begin: (source: "pointer" | "focus", delayMs: number | undefined) => void;
-    /** Records that the pointer or focus left; a pointer leaving during touch input is ignored. */
-    readonly end: (source: "pointer" | "focus") => void;
-    readonly reset: () => void;
-};
-/** Tracks whether the last pointer input was touch; the returned function detaches. */
-export declare function attachPointerModalityTracking(): () => void;
-/** One link's prefetch intent: an observer handle held from a pointer's or focus's arrival until either leaves. */
-export declare function createLinkIntent(input: {
-    readonly coordinator: ClientCoordinatorService;
-    readonly getHrefFn: () => string;
-    readonly skipWorkIndicator: boolean;
-}): LinkIntent;

package/dist/client/materialize.d.ts

@@ -1,21 +0,0 @@
-import { Effect } from "effect";
-import type { DecodedRoute } from "./payload.ts";
-import type { ViewDefinition } from "./view-definition.ts";
-export type MaterializedRoute = DecodedRoute & {
-    readonly definition: ViewDefinition | undefined;
-};
-export type ModuleLoadError = {
-    readonly _tag: "ModuleLoadError";
-    readonly url: string;
-    readonly cause: unknown;
-};
-/** Native imports cache production modules; development retains accepted replacement namespaces. */
-export declare function enableDevelopmentModules(): {
-    replaceFn(input: {
-        readonly url: string;
-        readonly module: Readonly<Record<string, unknown>>;
-    }): Map<unknown, unknown>;
-    closeFn(): void;
-};
-/** Loads one position independently, retaining its decoded facts and selected view. */
-export declare function materializeRoute(route: DecodedRoute): Effect.Effect<MaterializedRoute, ModuleLoadError>;

package/dist/client/modules.d.ts

@@ -1,2 +0,0 @@
-/** Writes a `modulepreload` link for each module path that has none yet. */
-export declare function preloadModules(paths: ReadonlyArray<string>): void;

package/dist/client/navigation.d.ts

@@ -1,47 +0,0 @@
-import { Duration, Effect, Result, type Schedule, Scope } from "effect";
-import { type CommitDependencies } from "./commit.ts";
-import type { ClientCore } from "./core.ts";
-import { NavigationError, RevalidationError } from "./errors.ts";
-import { type BrowserPosition } from "./history.ts";
-import { type PrefetchOwner } from "./prefetch.ts";
-import { type PreparationDependencies, type PreparedRoute } from "./prepare.ts";
-import type { QueryOwner } from "./queries.ts";
-import type { Frame } from "./state.ts";
-import type { NavigationOptions, NavigationResult, RevalidationResult } from "./types.ts";
-export type NavigationOwner = {
-    readonly navigate: (href: string, options: NavigationOptions) => Effect.Effect<NavigationResult, NavigationError>;
-    /** Records a target failure that happened before a navigation candidate existed. */
-    readonly recordTargetFailure: (error: NavigationError) => void;
-    /** Starts the navigation now and returns its observation. */
-    readonly begin: (href: string, options: NavigationOptions) => Effect.Effect<NavigationResult, NavigationError>;
-    /** Registers a demand when executed and awaits its qualifying result. */
-    readonly revalidate: (options: {
-        readonly skipWorkIndicator: boolean;
-    }) => Effect.Effect<RevalidationResult, RevalidationError>;
-    /** Registers a demand now and returns the observation of that demand. */
-    readonly requireRefresh: (options: {
-        readonly skipWorkIndicator: boolean;
-    }) => Effect.Effect<RevalidationResult, RevalidationError>;
-    /** Commits the boot preparation, whose entries' activations `scope` already holds. */
-    readonly commitBoot: (prepared: PreparedRoute, scope: Scope.Closeable, position: BrowserPosition) => Result.Result<Frame, NavigationError>;
-    /** Advances the session generation, retires every reusable value, and awaits fresh data. */
-    readonly invalidate: () => Effect.Effect<RevalidationResult, RevalidationError>;
-    readonly queries: QueryOwner;
-    /** Attaches popstate and focus handling; the returned function detaches them. */
-    readonly attachBrowserListeners: () => () => void;
-    /** Settles every navigation that waited for the first frame: boot's outcome decides whether it starts or fails. */
-    readonly settleBoot: (outcome: Result.Result<void, unknown>) => void;
-    /** Retires all prefetch preparations and retained snapshots. */
-    readonly retireReusable: () => void;
-    /** Retires every reusable value and outstanding observation; disposal calls it. */
-    readonly retireAll: () => void;
-};
-export declare function createNavigation(core: PreparationDependencies & CommitDependencies & Pick<ClientCore, "retireGeneration">, prefetch: PrefetchOwner, options: {
-    readonly enableViewTransitions: boolean;
-    readonly revalidateOnWindowFocus: {
-        readonly staleTime: Duration.Input;
-        readonly skipWorkIndicator: boolean;
-    } | undefined;
-    /** Runs a failed refresh attempt again under this schedule; without one a failed refresh fails once. */
-    readonly refreshRetrySchedule: Schedule.Schedule<unknown, RevalidationError> | undefined;
-}): NavigationOwner;

package/dist/client/payload.d.ts

@@ -1,54 +0,0 @@
-import type { CompiledNestedPattern } from "@vorma/primitives/matcher";
-import { Result } from "effect";
-import type { SearchContractDocument } from "../universal/protocol-schemas.ts";
-import { type TransportDecodeError } from "../universal/value-transport.ts";
-import type { HeadSections } from "./head.ts";
-export type DecodedRoute = {
-    readonly pattern: string;
-    readonly params: Readonly<Record<string, string>>;
-    readonly splatValues: ReadonlyArray<string>;
-    /** The pattern as the server's matcher holds it; the registry learns it for early client loader starts. */
-    readonly compiledPattern: CompiledNestedPattern;
-    /** The check-free decoded contract document that parses a URL's search; null for a route without one. */
-    readonly searchContract: SearchContractDocument | null;
-    /** The search the server parsed and validated for this route's loader; undefined for a route without a search contract. */
-    readonly searchInput: unknown;
-    readonly moduleReference: {
-        readonly url: string;
-        readonly exportNames: ReadonlyArray<string>;
-    } | null;
-    readonly loaderData: unknown;
-};
-export type ServerRouteError = {
-    /** The failed position follows the successful route prefix. Its metadata is not disclosed. */
-    readonly index: number;
-    readonly status: number;
-    readonly clientMessage: string;
-};
-export type DecodedRoutePayload = {
-    readonly routes: ReadonlyArray<DecodedRoute>;
-    readonly serverError: ServerRouteError | undefined;
-};
-export type DecodedPayload = DecodedRoutePayload & {
-    readonly head: HeadSections;
-    readonly deps: ReadonlyArray<string>;
-    readonly cssBundles: ReadonlyArray<string>;
-    readonly staticAssets: ReadonlyArray<string>;
-};
-export type BootstrapPayload = DecodedRoutePayload & {
-    readonly clientBuildId: string;
-    /** Whether the development server served the document. */
-    readonly developmentMode: boolean;
-    readonly deploymentId: string | undefined;
-};
-/** A transported value on a route record whose marks do not restore it. */
-export type PayloadReadError = {
-    readonly _tag: "PayloadReadError";
-    readonly pattern: string;
-    readonly field: "search_input" | "loader_data";
-    readonly cause: TransportDecodeError;
-};
-/** Reads a navigation payload this build's server wrote. */
-export declare function readPayload(raw: unknown): Result.Result<DecodedPayload, PayloadReadError>;
-/** Reads the initial document payload, including build identity. */
-export declare function readBootstrapPayload(raw: unknown): Result.Result<BootstrapPayload, PayloadReadError>;

package/dist/client/prefetch.d.ts

@@ -1,28 +0,0 @@
-import { Effect } from "effect";
-import type { ClientCore } from "./core.ts";
-import { NavigationError, PrefetchError } from "./errors.ts";
-import { type PreparationDependencies, type PreparationOutcome } from "./prepare.ts";
-export type ConsumedPreparation = {
-    /** The preparation's outcome; a redirect or refusal is the consumer's to handle. */
-    readonly result: Effect.Effect<PreparationOutcome, NavigationError>;
-    /** The sequence current when the preparation started; its read is newer. */
-    readonly startSequence: number;
-    /** Ends the preparation: the consumer calls it once the frame holds what it needs, or when it stops. */
-    readonly release: () => void;
-};
-export type PrefetchOwner = {
-    /** Holds an observer handle for the Effect's lifetime and observes readiness. */
-    readonly awaitReadiness: (url: URL, options: {
-        readonly skipWorkIndicator: boolean;
-    }) => Effect.Effect<void, PrefetchError>;
-    /** Holds an observer handle until interrupted; intent that outlasts readiness uses this. */
-    readonly holdUntilInterrupted: (url: URL, options: {
-        readonly skipWorkIndicator: boolean;
-    }) => Effect.Effect<never, PrefetchError>;
-    /** Transfers the destination's preparation to navigation, if one exists. */
-    readonly takeForNavigation: (destination: string) => ConsumedPreparation | null;
-    readonly retirePreparations: () => void;
-};
-/** The part of an address a preparation serves: its path and query. */
-export declare function readDestination(url: URL): string;
-export declare function createPrefetch(core: PreparationDependencies & Pick<ClientCore, "updateState" | "forkFiber">): PrefetchOwner;

package/dist/client/prepare.d.ts

@@ -1,47 +0,0 @@
-import { Effect, Exit, Scope } from "effect";
-import { type ClientLoaderTrigger } from "./client-loaders.ts";
-import type { ClientCore } from "./core.ts";
-import { NavigationError } from "./errors.ts";
-import type { HeadSections } from "./head.ts";
-import { type DecodedPayload } from "./payload.ts";
-import type { RouteEntry, RouteErrorState } from "./state.ts";
-import type { BuildMismatch, RequestKind } from "./types.ts";
-export type RouteReadSource = {
-    readonly kind: "request";
-    readonly url: URL;
-    readonly requestKind: RequestKind;
-} | {
-    readonly kind: "payload";
-    readonly url: URL;
-    readonly payload: DecodedPayload;
-};
-export type PreparedRoute = {
-    readonly url: URL;
-    readonly entries: ReadonlyArray<RouteEntry>;
-    readonly error: RouteErrorState | null;
-    readonly head: HeadSections;
-    readonly cssBundles: ReadonlyArray<string>;
-    /** The sequence of the read that produced this route. */
-    readonly sequence: number;
-    readonly generation: number;
-};
-export type PreparationOutcome = {
-    readonly _tag: "Prepared";
-    readonly prepared: PreparedRoute;
-} | {
-    readonly _tag: "Redirect";
-    readonly href: string;
-} | {
-    readonly _tag: "BuildSkew";
-    readonly mismatch: BuildMismatch;
-};
-export type PreparationDependencies = Pick<ClientCore, "getClientBuildId" | "getDeploymentId" | "prepareRequest" | "provideClient" | "advanceSequence" | "getState" | "activations" | "clientLoaders" | "reportBuildMismatch" | "runsInDevelopmentMode" | "publishEvent">;
-/** Prepares one destination. Known client loaders start before the read settles when `prestart` is set. */
-export declare function prepareRoute(core: PreparationDependencies, input: {
-    readonly source: RouteReadSource;
-    readonly trigger: ClientLoaderTrigger;
-    readonly historyState: unknown;
-    readonly prestart: boolean;
-    /** Called once: at the ready milestone, or with the failure when preparation ends before it. */
-    readonly reportReadinessFn: ((exit: Exit.Exit<void, NavigationError>) => void) | undefined;
-}): Effect.Effect<PreparationOutcome, NavigationError, Scope.Scope>;

package/dist/client/projections.d.ts

@@ -1,26 +0,0 @@
-import { Option } from "effect";
-import { Atom } from "effect/unstable/reactivity";
-import { type Frame, type RouteEntry, type RouteErrorState } from "./state.ts";
-import type { BuildMismatch, ClientLifecycle, NavigationState, OperationId, OperationState, RevalidationState, RouteState, RouteError, WorkState } from "./types.ts";
-export declare const lifecycleAtom: Atom.Atom<ClientLifecycle>;
-export declare const committedFrameAtom: Atom.Atom<Frame | null>;
-/** Projects server-public fields or preserves a browser-local cause according to its source. */
-export declare function projectRouteError(error: Pick<RouteErrorState, "pattern" | "source" | "error">): RouteError;
-/** The public route state of a frame. */
-export declare function projectRouteState(frame: Pick<Frame, "href" | "historyState" | "error"> & {
-    readonly entries: ReadonlyArray<Pick<RouteEntry, "pattern" | "params" | "splatValues">>;
-}): RouteState;
-export declare const routeStateAtom: Atom.Atom<Option.Option<RouteState>>;
-export declare const navigationStateAtom: Atom.Atom<NavigationState>;
-export declare const revalidationStateAtom: Atom.Atom<RevalidationState>;
-/**
- * Active queries depend on this; it changes only when a demand registers. It
- * is eager because its dependents are lazy runtime computations behind
- * wrappers, and the registry recomputes a lazy atom's lazy dependents only
- * when the atom itself is recomputed.
- */
-export declare const refreshEpochAtom: Atom.Atom<number>;
-export declare const buildMismatchAtom: Atom.Atom<Option.Option<BuildMismatch>>;
-export declare const workStateAtom: Atom.Atom<WorkState>;
-/** One operation's state while it is tracked; the observer retains the settled value afterward. */
-export declare const getOperationStateAtom: (arg: OperationId) => Atom.Atom<Option.Option<OperationState>>;

package/dist/client/queries.d.ts

@@ -1,33 +0,0 @@
-import { Option } from "effect";
-import { Atom, AsyncResult } from "effect/unstable/reactivity";
-import type { EndpointCallFailure, EndpointCallOutput, QueryEndpointCallInput } from "./contracts.ts";
-import type { EndpointFrameworkError, QueryResponse } from "./endpoints.ts";
-import type { QueryRedirected } from "./errors.ts";
-import { ClientCoordinator } from "./runtime.ts";
-export type QueryEndpointOutput<Input extends QueryEndpointCallInput> = QueryResponse<EndpointCallOutput<Input>>;
-export type QueryAtom<Input extends QueryEndpointCallInput, RuntimeError> = Atom.Atom<AsyncResult.AsyncResult<QueryEndpointOutput<Input>, EndpointCallFailure<Input, EndpointFrameworkError | QueryRedirected> | RuntimeError>>;
-/** The facts an acknowledgment carries; a read that never dispatched has no sequence. */
-export type QueryAcknowledgment = {
-    readonly id: string;
-    readonly dispatched: {
-        readonly sequence: number;
-        readonly generation: number;
-    } | undefined;
-    readonly success: boolean;
-};
-/** One computation of a query's reading atom, told apart from its successors. */
-export type QueryComputation = {
-    readonly id: string;
-    readonly token: symbol;
-};
-export type QueryOwner = {
-    /** A computation evaluated; the outstanding demand expects its read. */
-    readonly expect: (computation: QueryComputation) => void;
-    /** A computation's scope closed; without a successor the query is no longer expected. */
-    readonly release: (computation: QueryComputation) => void;
-    readonly acknowledge: (acknowledgment: QueryAcknowledgment) => void;
-};
-export declare function createQueryAtom<const Input extends QueryEndpointCallInput, R extends ClientCoordinator, RuntimeError>(input: {
-    readonly runtime: Atom.AtomRuntime<R, RuntimeError>;
-    readonly request: Input | Atom.Atom<Option.Option<Input>>;
-}): QueryAtom<Input, RuntimeError>;