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

package/dist/client/errors.d.ts

@@ -1,87 +0,0 @@
-import { Cause, type Effect } from "effect";
-import type { RedirectStatus } from "../universal/protocol-schemas.ts";
-import type { NavigationResult, OperationId, PublicRouteError } from "./types.ts";
-type CommandBoundary = {
-    readonly pattern: string;
-    readonly operationId?: OperationId;
-    readonly method?: string;
-};
-declare const InputError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
-    readonly _tag: "InputError";
-} & Readonly<A>;
-export declare class InputError extends InputError_base<CommandBoundary & {
-    readonly message: string;
-    readonly cause?: unknown;
-}> {
-}
-declare const BuildMismatchError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
-    readonly _tag: "BuildMismatchError";
-} & Readonly<A>;
-export declare class BuildMismatchError extends BuildMismatchError_base<CommandBoundary & {
-    readonly message: string;
-}> {
-}
-declare const TransportError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
-    readonly _tag: "TransportError";
-} & Readonly<A>;
-export declare class TransportError extends TransportError_base<CommandBoundary & {
-    readonly message: string;
-    readonly cause: unknown;
-    readonly status?: number;
-}> {
-}
-declare const HandlerError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
-    readonly _tag: "HandlerError";
-} & Readonly<A>;
-export declare class HandlerError extends HandlerError_base<CommandBoundary & PublicRouteError> {
-}
-declare const CancelledByDedupeKeyError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
-    readonly _tag: "CancelledByDedupeKeyError";
-} & Readonly<A>;
-/** A later endpoint call with the same dedupe key cancelled this call's request. */
-export declare class CancelledByDedupeKeyError extends CancelledByDedupeKeyError_base<CommandBoundary & {
-    readonly dedupeKey: string;
-}> {
-}
-declare const NavigationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
-    readonly _tag: "NavigationError";
-} & Readonly<A>;
-export declare class NavigationError extends NavigationError_base<{
-    readonly stage: "target" | "request" | "assets" | "transition" | "publication";
-    readonly cause: Cause.Cause<unknown>;
-}> {
-}
-declare const RevalidationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
-    readonly _tag: "RevalidationError";
-} & Readonly<A>;
-export declare class RevalidationError extends RevalidationError_base<{
-    readonly reason: "route" | "query" | "build-mismatch" | "superseded" | "disposed";
-    readonly cause: Cause.Cause<unknown>;
-}> {
-}
-declare const PrefetchError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
-    readonly _tag: "PrefetchError";
-} & Readonly<A>;
-export declare class PrefetchError extends PrefetchError_base<{
-    /** `takenByNavigation`: a navigation took the preparation, so readiness is no longer observable. */
-    readonly reason: "target" | "unavailable" | "preparation" | "superseded" | "takenByNavigation";
-    readonly cause?: unknown;
-}> {
-}
-/** The navigation a query redirect started, observable without repeating the query. */
-export type QueryNavigation = Effect.Effect<NavigationResult, NavigationError>;
-declare const QueryRedirected_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
-    readonly _tag: "QueryRedirected";
-} & Readonly<A>;
-export declare class QueryRedirected extends QueryRedirected_base<CommandBoundary & {
-    readonly redirectUrl: string;
-    /** The status the server intended; `undefined` when the browser followed the redirect itself. */
-    readonly redirectStatus: RedirectStatus | undefined;
-    readonly navigation: QueryNavigation;
-}> {
-}
-/** The sanitized presentation of any failure: explicit public fields, or a generic 500. */
-export declare function sanitizeRouteError(error: unknown): PublicRouteError;
-/** Recognizes typed navigation control without consuming defects or composite failures. */
-export declare function getQueryRedirect(error: unknown): QueryRedirected | undefined;
-export {};

package/dist/client/freshness.d.ts

@@ -1,51 +0,0 @@
-import { Deferred } from "effect";
-import { RevalidationError } from "./errors.ts";
-import type { FreshnessFacts } from "./state.ts";
-import type { RevalidationResult } from "./types.ts";
-export type Waiter = Deferred.Deferred<RevalidationResult, RevalidationError>;
-export type FreshnessTransition = {
-    readonly facts: FreshnessFacts;
-    /** Completions to run after the state record has been replaced. */
-    readonly complete: ReadonlyArray<() => void>;
-    /** Whether a refresh attempt should start now. */
-    readonly startAttempt: boolean;
-};
-/**
- * Registers a demand after `sequence` from an authorized trigger; merges into
- * an outstanding demand. The epoch advances with it, and every query
- * computation that evaluates for the new epoch expects itself through
- * `expectQueries`; expectations from before the merge are dropped, because a
- * retained query that no consumer holds does not evaluate and cannot answer.
- */
-export declare function registerDemand(facts: FreshnessFacts, input: {
-    readonly sequence: number;
-    readonly waiter: Waiter | undefined;
-    readonly skipWorkIndicator: boolean;
-}): FreshnessTransition;
-/** An attempt starts for the outstanding demand, recording the sequence it covers and taking the demand's waiters. */
-export declare function startAttempt(facts: FreshnessFacts): FreshnessFacts;
-/** The running attempt failed and the application's schedule will run another; its waiters wait on. */
-export declare function holdAttemptForRetry(facts: FreshnessFacts, error: RevalidationError): FreshnessTransition;
-/** A read with `sequence` committed without a route error. */
-export declare function satisfyDemand(facts: FreshnessFacts, input: {
-    readonly sequence: number;
-}): FreshnessTransition;
-/** An expected query read settled: a qualifying success acknowledges; a failure of a qualifying read fails the attempt. */
-export declare function acknowledgeQuery(facts: FreshnessFacts, input: {
-    readonly id: string;
-    readonly sequence: number | undefined;
-    readonly success: boolean;
-}): FreshnessTransition;
-/** Query computations evaluated for the outstanding demand's epoch; each must acknowledge or be released. */
-export declare function expectQueries(facts: FreshnessFacts, ids: ReadonlySet<string>): FreshnessTransition;
-/** A query's computation was released with no successor; a demand waiting only on it completes. */
-export declare function releaseQuery(facts: FreshnessFacts, id: string): FreshnessTransition;
-/** The running attempt failed. Its captured batch fails; a newer demand starts another attempt. */
-export declare function failAttempt(facts: FreshnessFacts, error: RevalidationError): FreshnessTransition;
-/** The navigation that was running the attempt ended without settling it; the attempt's waiters return to the demand. */
-export declare function abandonAttempt(facts: FreshnessFacts): FreshnessTransition;
-/** Whether a new attempt may start: a demand exists, no attempt is running, and no failed attempt already covered the demand's sequence. */
-export declare function canStartAttempt(facts: FreshnessFacts): boolean;
-/** Retires the demand and settles every waiter with the given error. */
-export declare function retireDemand(facts: FreshnessFacts, error: RevalidationError): FreshnessTransition;
-export declare function makeRevalidationError(reason: RevalidationError["reason"], cause: unknown): RevalidationError;

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;