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

package/dist/client/assembly.d.ts

@@ -1,40 +0,0 @@
-import { Effect, Exit, Layer } from "effect";
-import type { Duration, Schedule } from "effect";
-import type { ClientCore } from "./core.ts";
-import type { RevalidationError } from "./errors.ts";
-import { type NavigationOwner } from "./navigation.ts";
-import { type PrefetchOwner } from "./prefetch.ts";
-import { type PrepareRequestFn } from "./request.ts";
-import { type ClientCoordinatorService } from "./runtime.ts";
-import type { ClientBootError } from "./types.ts";
-import { type WorkIndicatorOptions } from "./work-indicator.ts";
-export type ClientApplicationOptions = {
-    readonly workIndicator?: WorkIndicatorOptions;
-    readonly clientOnlyServices?: Layer.Layer<unknown, unknown, unknown>;
-    readonly universalServices?: Layer.Layer<unknown, unknown>;
-    readonly browserProgram?: Effect.Effect<unknown, unknown, unknown>;
-    readonly prepareRequestFn?: PrepareRequestFn<unknown>;
-    readonly revalidateOnWindowFocus?: {
-        readonly staleTime: Duration.Input;
-        readonly skipWorkIndicator?: boolean;
-    };
-    readonly enableViewTransitions?: boolean;
-    /** Runs a failed refresh attempt again under this schedule; without one a failed refresh fails once. */
-    readonly refreshRetrySchedule?: Schedule.Schedule<unknown, RevalidationError>;
-};
-export type ClientApplication = {
-    readonly core: ClientCore;
-    readonly coordinator: ClientCoordinatorService;
-    readonly navigation: NavigationOwner;
-    readonly prefetch: PrefetchOwner;
-    /** Remains readable after disposal closes the atom registry. */
-    checkDisposed(): boolean;
-    boot(): Promise<Exit.Exit<void, ClientBootError>>;
-    dispose(): Promise<void>;
-};
-export declare function createClientApplication(input: {
-    readonly options: ClientApplicationOptions;
-    readonly scheduleTaskFn: (task: () => void) => () => void;
-    readonly renderFn: (rootElement: HTMLElement) => void;
-    readonly disposeRendererFn: () => void;
-}): ClientApplication;

package/dist/client/browser-http-client.d.ts

@@ -1,10 +0,0 @@
-import { Effect } from "effect";
-import type { Scope } from "effect";
-import { type HttpClientRequest, type HttpClientResponse, type HttpClientError } from "effect/unstable/http";
-/** Executes a framework request with native Fetch controls and its caller's scope. */
-export declare function executeBrowserRequest(request: HttpClientRequest.HttpClientRequest): Effect.Effect<{
-    readonly response: HttpClientResponse.HttpClientResponse;
-    readonly followedUrl: string | undefined;
-}, HttpClientError.HttpClientError, Scope.Scope>;
-/** The observed redirect destination, excluding Vorma's route query keys. */
-export declare function findFollowedRedirect(followedUrl: string | undefined, requested: URL): string | null;

package/dist/client/client-loaders.d.ts

@@ -1,93 +0,0 @@
-import { Cause, Deferred, Effect, Fiber, Option, type Scope } from "effect";
-import { AsyncResult } from "effect/unstable/reactivity";
-import type { ClientCore } from "./core.ts";
-import type { MaterializedRoute } from "./materialize.ts";
-import type { DecodedRoute } from "./payload.ts";
-import type { createLearnedMatcher, parseSearch } from "./route-matching.ts";
-import type { RouteActivation } from "./services.ts";
-import type { ViewDefinition } from "./view-definition.ts";
-export type ClientLoaderTrigger = "boot" | "navigation" | "revalidation" | "prefetch";
-export type KnownMatch = {
-    readonly pattern: string;
-    readonly params: Readonly<Record<string, string>>;
-    readonly splatValues: ReadonlyArray<string>;
-    readonly input: unknown;
-};
-export type EligibleMatch = {
-    readonly match: KnownMatch;
-    readonly view: ViewDefinition | undefined;
-};
-/** The one server result every client loader of a candidate selects from. */
-export type ServerConfirmation = ReadonlyArray<DecodedRoute>;
-export declare function toKnownMatch(route: DecodedRoute): KnownMatch;
-export type ClientLoaderContext = {
-    readonly trigger: ClientLoaderTrigger;
-    readonly href: string;
-    readonly historyState: unknown;
-    readonly pattern: string;
-    readonly params: Readonly<Record<string, string>>;
-    readonly splatValues: ReadonlyArray<string>;
-    readonly input: unknown;
-    readonly knownRouteMatches: ReadonlyArray<KnownMatch>;
-    readonly serverConfirmedRouteMatches: Effect.Effect<ReadonlyArray<KnownMatch>>;
-    readonly loaderData: Effect.Effect<unknown>;
-    readonly getLoaderData: (pattern: string) => Effect.Effect<Option.Option<unknown>>;
-};
-export type ClientLoaderFn = (context: ClientLoaderContext) => Effect.Effect<unknown, unknown, unknown>;
-export type StartedClientLoader = {
-    readonly pattern: string;
-    readonly fiber: Fiber.Fiber<unknown, unknown>;
-};
-/** The functions of `route-matching.ts` that the registry calls once the module has loaded. */
-export type RouteMatchingModule = {
-    readonly createLearnedMatcher: typeof createLearnedMatcher;
-    readonly parseSearch: typeof parseSearch;
-};
-export type ClientLoaderRegistry = {
-    readonly replaceViewsFn: (replacements: ReadonlyMap<unknown, unknown>) => void;
-    readonly recordConfirmedChain: (input: {
-        readonly url: URL;
-        readonly routes: ReadonlyArray<MaterializedRoute>;
-    }) => void;
-    /** Installs the matching module once it has loaded; until then nothing starts early. */
-    readonly installMatching: (module: RouteMatchingModule) => void;
-    /** The proven chain prefix for `url`, with each position's search input parsed but not validated. */
-    readonly findEligibleMatches: (url: URL) => ReadonlyArray<EligibleMatch>;
-};
-export declare function createClientLoaderRegistry(): ClientLoaderRegistry;
-/** Forks one client loader into the current scope, joined to its candidate's server result. */
-export declare function startClientLoader(provideClientFn: ClientCore["provideClient"], input: {
-    readonly clientLoader: ClientLoaderFn;
-    readonly trigger: ClientLoaderTrigger;
-    readonly href: string;
-    readonly historyState: unknown;
-    readonly match: KnownMatch;
-    readonly known: ReadonlyArray<KnownMatch>;
-    readonly confirmation: Deferred.Deferred<ServerConfirmation>;
-    readonly activation: RouteActivation | undefined;
-}): Effect.Effect<StartedClientLoader, never, Scope.Scope>;
-export type ClientLoaderOutcome = {
-    /** Each settled client loader's result by route position; a position whose loader did not settle has no entry. */
-    readonly results: ReadonlyMap<number, AsyncResult.AsyncResult<unknown, unknown>>;
-    readonly failure: {
-        readonly index: number;
-        readonly pattern: string;
-        readonly cause: Cause.Cause<unknown>;
-    } | null;
-};
-export type RunningClientLoader = {
-    readonly index: number;
-    readonly pattern: string;
-    readonly fiber: Fiber.Fiber<unknown, unknown>;
-};
-/** One route of a candidate with the activation its client loader runs under. */
-export type ClientLoaderPosition = {
-    readonly route: MaterializedRoute;
-    readonly activation: RouteActivation | undefined;
-};
-/**
- * Collects loader outcomes and reports the earliest failure in route order.
- * The preparation owner observes failures and interrupts later work as soon
- * as each loader starts, including before this collection begins.
- */
-export declare function awaitClientLoaders(publishEventFn: ClientCore["publishEvent"], running: ReadonlyArray<RunningClientLoader>): Effect.Effect<ClientLoaderOutcome>;

package/dist/client/commit.d.ts

@@ -1,41 +0,0 @@
-import { Result, Scope } from "effect";
-import type { ClientCore } from "./core.ts";
-import { NavigationError } from "./errors.ts";
-import { type HeadSections } from "./head.ts";
-import { type BrowserPosition } from "./history.ts";
-import type { ScrollTarget } from "./scroll.ts";
-import type { Frame, RouteEntry, RouteErrorState } from "./state.ts";
-import type { RouteUpdateReason } from "./types.ts";
-export type ScrollIntent = {
-    readonly target: ScrollTarget;
-    /** The entry whose render must exist before the scroll applies. */
-    readonly entryIndex: number;
-};
-export type CommitPosition = {
-    readonly kind: "write";
-    readonly href: string;
-    readonly replace: boolean;
-    readonly userState: unknown;
-    readonly key: string;
-} | {
-    readonly kind: "adopt";
-    readonly position: BrowserPosition;
-};
-export type CommitInput = {
-    readonly reason: RouteUpdateReason;
-    readonly entries: ReadonlyArray<RouteEntry>;
-    readonly error: RouteErrorState | null;
-    readonly head: HeadSections;
-    readonly cssBundles: ReadonlyArray<string>;
-    /** Whether this commit updates the document or adopts its server-rendered state. */
-    readonly documentUpdate: "apply" | "adopt";
-    readonly position: CommitPosition;
-    readonly scrollIntent: ScrollIntent | undefined;
-    /** When the entries' data was read; a commit that reuses data keeps that time. */
-    readonly committedAt: number | undefined;
-    /** The scope that holds the entries' activations. */
-    readonly scope: Scope.Closeable;
-};
-export type CommitDependencies = Pick<ClientCore, "getState" | "updateState" | "publishEvent" | "getClientBuildId" | "forkFiber">;
-/** Accepts a prepared route as the committed frame. Callers hold the uninterruptible region. */
-export declare function commitFrame(core: CommitDependencies, input: CommitInput): Result.Result<Frame, NavigationError>;

package/dist/client/contracts.d.ts

@@ -1,192 +0,0 @@
-import type { Effect, Option } from "effect";
-import type { AsyncResult } from "effect/unstable/reactivity";
-import type { MissingGeneratedApplicationKey } from "../universal/generated-types.ts";
-import type { ClientApplicationContracts } from "./index.ts";
-type UiContract = {
-    readonly input: unknown;
-    readonly output: unknown;
-    readonly search: unknown;
-    readonly clientLoader: {
-        readonly success: unknown;
-        readonly error: unknown;
-        readonly requirements: unknown;
-    } | undefined;
-};
-type EndpointContract = {
-    readonly kind: "query" | "mutation" | "stream";
-    readonly input: unknown;
-    readonly output: unknown;
-    readonly errors: unknown;
-};
-type RegisteredUiContracts = ClientApplicationContracts extends {
-    readonly ui: infer Contracts;
-} ? Contracts : Readonly<Record<MissingGeneratedApplicationKey, UiContract>>;
-type RegisteredEndpointContracts = ClientApplicationContracts extends {
-    readonly endpoints: infer Contracts;
-} ? Contracts : Readonly<Record<MissingGeneratedApplicationKey, EndpointContract>>;
-export type RoutePattern = Extract<keyof RegisteredUiContracts, string>;
-type PatternParameterName<Pattern extends string> = Pattern extends `${infer Segment}/${infer Rest}` ? SegmentParameterName<Segment> | PatternParameterName<Rest> : SegmentParameterName<Pattern>;
-type SegmentParameterName<Segment extends string> = Segment extends `:${infer Name}` ? Name : never;
-export type PatternParams<Pattern extends string> = [
-    PatternParameterName<Pattern>
-] extends [never] ? {
-    readonly params?: never;
-} : {
-    readonly params: Readonly<Record<PatternParameterName<Pattern>, string>>;
-};
-export type PatternSplat<Pattern extends string> = Pattern extends `${string}/*` ? {
-    readonly splatValues: ReadonlyArray<string>;
-} : {
-    readonly splatValues?: never;
-};
-export type LoaderRoutePattern = {
-    [Pattern in RoutePattern]: RegisteredUiContracts[Pattern] extends {
-        readonly output: infer Output;
-    } ? [Output] extends [undefined] ? never : Pattern : never;
-}[RoutePattern];
-/** The decoded server loader output of a route; `undefined` for a route without a loader. */
-export type LoaderData<Pattern extends RoutePattern> = RegisteredUiContracts[Pattern] extends {
-    readonly output: infer Output;
-} ? Output : never;
-export type RouteInput<Pattern extends RoutePattern> = RegisteredUiContracts[Pattern] extends {
-    readonly input: infer Input;
-} ? Input : undefined;
-export type RouteMatch<Pattern extends RoutePattern> = {
-    readonly pattern: Pattern;
-    readonly params: Readonly<Record<PatternParameterName<Pattern>, string>>;
-    readonly splatValues: ReadonlyArray<string>;
-    readonly input: RouteInput<Pattern>;
-};
-export type AnyRouteMatch = {
-    [Pattern in RoutePattern]: RouteMatch<Pattern>;
-}[RoutePattern];
-export type ClientLoaderRoutePattern = {
-    [Pattern in RoutePattern]: RegisteredUiContracts[Pattern] extends {
-        readonly clientLoader: {
-            readonly success: unknown;
-            readonly error: unknown;
-            readonly requirements: unknown;
-        };
-    } ? Pattern : never;
-}[RoutePattern];
-export type ClientLoaderData<Pattern extends ClientLoaderRoutePattern> = RegisteredUiContracts[Pattern] extends {
-    readonly clientLoader: {
-        readonly success: infer Success;
-    };
-} ? Success : never;
-export type ClientLoaderState<Pattern extends ClientLoaderRoutePattern> = RegisteredUiContracts[Pattern] extends {
-    readonly clientLoader: {
-        readonly success: infer Success;
-        readonly error: infer Error;
-        readonly requirements: unknown;
-    };
-} ? AsyncResult.AsyncResult<Success, Error> : never;
-type RequiredKeys<Value> = Value extends object ? {
-    [Key in keyof Value]-?: {} extends Pick<Value, Key> ? never : Key;
-}[keyof Value] : never;
-type RouteInputField<Pattern extends RoutePattern> = RegisteredUiContracts[Pattern] extends {
-    readonly search: infer Search;
-} ? [Search] extends [undefined] ? {
-    readonly input?: never;
-} : RequiredKeys<Search> extends never ? {
-    readonly input?: Search;
-} : {
-    readonly input: Search;
-} : {
-    readonly input?: never;
-};
-type DestinationPattern<Pattern extends string> = Pattern extends `${infer Prefix}/_index` ? Pattern | (Prefix extends "" ? "/" : Prefix) : Pattern;
-type PatternRouteTarget<Pattern extends RoutePattern> = Pattern extends string ? {
-    readonly href?: never;
-    readonly pattern: DestinationPattern<Pattern>;
-    readonly hash?: string;
-} & PatternParams<Pattern> & PatternSplat<Pattern> & RouteInputField<Pattern> : never;
-export type RawHrefTarget = {
-    readonly href: string;
-    readonly pattern?: never;
-    readonly params?: never;
-    readonly splatValues?: never;
-    readonly input?: never;
-    readonly hash?: never;
-};
-/** A generated pattern target, or a raw href when no pattern is selected. */
-export type RouteTarget<Pattern extends RoutePattern | undefined = undefined> = Pattern extends RoutePattern ? PatternRouteTarget<Pattern> : PatternRouteTarget<RoutePattern> | RawHrefTarget;
-export type RouteUrlInput = PatternRouteTarget<RoutePattern>;
-/** A target as a command receives it: a pattern target or a raw href. */
-export type NavigationTargetInput = RouteUrlInput | RawHrefTarget;
-export type EndpointRequestOptions = Omit<RequestInit, "method" | "body" | "signal">;
-/** The runtime representation of an endpoint call after its public contract is checked. */
-export type EndpointCallInput = {
-    readonly method: string;
-    readonly pattern: string;
-    readonly params?: Readonly<Record<string, string>>;
-    readonly splatValues?: ReadonlyArray<string>;
-    readonly input?: unknown;
-    readonly body?: never;
-    readonly skipWorkIndicator?: boolean;
-    readonly skipAutoRevalidate?: boolean;
-    readonly requestOptions?: EndpointRequestOptions;
-    /** A later call with the same key cancels this call's request while it is unfinished. */
-    readonly dedupeKey?: string;
-};
-type EndpointInput<Contract, Method extends string> = Contract extends {
-    readonly input: infer Input;
-} ? [Input] extends [undefined] ? {
-    readonly input?: never;
-} : {
-    readonly input: Input | (Method extends "GET" ? FormData : never);
-} : {
-    readonly input?: never;
-};
-type RegisteredEndpointCallInput<Kind extends "query" | "mutation"> = {
-    [Identity in Extract<keyof RegisteredEndpointContracts, string>]: RegisteredEndpointContracts[Identity] extends {
-        readonly kind: Kind;
-    } ? Identity extends `${infer Method} ${infer Pattern}` ? {
-        readonly method: Method;
-        readonly body?: never;
-        readonly pattern: Pattern;
-        readonly skipWorkIndicator?: boolean;
-        readonly requestOptions?: EndpointRequestOptions;
-        /** A later call with the same key cancels this call's request while it is unfinished. */
-        readonly dedupeKey?: string;
-    } & (Kind extends "mutation" ? {
-        readonly skipAutoRevalidate?: boolean;
-    } : {}) & PatternParams<Pattern> & PatternSplat<Pattern> & EndpointInput<RegisteredEndpointContracts[Identity], Method> : never : never;
-}[Extract<keyof RegisteredEndpointContracts, string>];
-type EndpointCallInputFor<Kind extends "query" | "mutation"> = ClientApplicationContracts extends {
-    readonly endpoints: unknown;
-} ? RegisteredEndpointCallInput<Kind> : EndpointCallInput & {
-    readonly pattern: MissingGeneratedApplicationKey;
-};
-export type QueryEndpointCallInput = EndpointCallInputFor<"query">;
-export type MutationEndpointCallInput = EndpointCallInputFor<"mutation">;
-export type EndpointCallOutput<Input extends EndpointCallInput> = ClientApplicationContracts extends {
-    readonly endpoints: infer Contracts;
-} ? `${Input["method"]} ${Input["pattern"]}` extends infer Identity extends keyof Contracts ? Contracts[Identity] extends {
-    readonly output: infer Output;
-} ? Output : never : never : never;
-/**
- * An operation's complete failure channel: the given framework failures plus
- * the operation's declared domain errors, each as the record of its fields
- * the server transported.
- */
-export type EndpointCallFailure<Input extends EndpointCallInput, Base> = ClientApplicationContracts extends {
-    readonly endpoints: infer Contracts;
-} ? `${Input["method"]} ${Input["pattern"]}` extends infer Identity extends keyof Contracts ? Contracts[Identity] extends {
-    readonly errors: infer Errors;
-} ? Base | Errors[keyof Errors] : Base : Base : Base;
-/** What a client loader receives: candidate facts now, server results as Effects joined to the candidate. */
-export type ClientLoaderContext<Pattern extends RoutePattern> = {
-    readonly trigger: "boot" | "navigation" | "revalidation" | "prefetch";
-    readonly href: string;
-    readonly historyState: unknown;
-    readonly pattern: Pattern;
-    readonly params: RouteMatch<Pattern>["params"];
-    readonly splatValues: RouteMatch<Pattern>["splatValues"];
-    readonly input: RouteInput<Pattern>;
-    readonly knownRouteMatches: ReadonlyArray<AnyRouteMatch>;
-    readonly serverConfirmedRouteMatches: Effect.Effect<ReadonlyArray<AnyRouteMatch>>;
-    readonly loaderData: Effect.Effect<LoaderData<Pattern>>;
-    readonly getLoaderData: <Target extends LoaderRoutePattern>(pattern: Target) => Effect.Effect<Option.Option<LoaderData<Target>>>;
-};
-export {};

package/dist/client/core.d.ts

@@ -1,45 +0,0 @@
-import type { Deferred, Effect, Fiber, FiberSet, Layer, Scope, Stream } from "effect";
-import type { HttpClientRequest } from "effect/unstable/http";
-import type { AtomRegistry } from "effect/unstable/reactivity";
-import type { ClientLoaderRegistry } from "./client-loaders.ts";
-import type { ClientRequestContext } from "./request.ts";
-import type { ClientUnavailableError } from "./runtime.ts";
-import type { ActivationMap } from "./services.ts";
-import type { ClientState } from "./state.ts";
-import type { BuildMismatch, ClientEvent } from "./types.ts";
-/**
- * The application's owned facilities, built once by the assembly. Command
- * modules receive the facilities that their operations require.
- */
-export type ClientCore = {
-    readonly registry: AtomRegistry.AtomRegistry;
-    readonly scope: Scope.Closeable;
-    readonly memoMap: Layer.MemoMap;
-    /** Tracks dispatched mutations for application disposal; each caller also retains native cancellation. */
-    readonly mutationFibers: FiberSet.FiberSet<unknown, unknown>;
-    readonly events: Stream.Stream<ClientEvent>;
-    readonly publishEvent: (event: ClientEvent) => void;
-    readonly getState: () => ClientState;
-    readonly updateState: (updateFn: (state: ClientState) => ClientState) => void;
-    /** Forks application-owned work into the application scope. */
-    readonly forkFiber: <A, E>(effect: Effect.Effect<A, E>) => Fiber.Fiber<A, E>;
-    /** Advances the monotonic sequence and returns it; reads and demands are ordered by it, never by wall clock. */
-    readonly advanceSequence: () => number;
-    /** Settles when the current session generation is retired; reads of that generation race it. */
-    readonly getGenerationRetirement: () => Deferred.Deferred<void>;
-    /** Advances the session generation and retires the previous one. */
-    readonly retireGeneration: () => void;
-    readonly getClientBuildId: () => string;
-    readonly getDeploymentId: () => string | undefined;
-    /** Whether the document was served by the development server. */
-    readonly runsInDevelopmentMode: () => boolean;
-    readonly clientLoaders: ClientLoaderRegistry;
-    /** Runs the application request decorator with assembled services. */
-    readonly prepareRequest: (context: ClientRequestContext) => Effect.Effect<HttpClientRequest.HttpClientRequest, unknown>;
-    /** Runs an Effect with the application's client services; before boot assembles them, they are unavailable. */
-    readonly provideClient: <A, E>(effect: Effect.Effect<A, E, unknown>) => Effect.Effect<A, E | ClientUnavailableError>;
-    /** Records a mismatch in state and publishes `BuildMismatchDetected`. */
-    readonly reportBuildMismatch: (mismatch: BuildMismatch) => void;
-    /** Route service activations by key, reference counted by their owners' scopes. */
-    readonly activations: ActivationMap;
-};

package/dist/client/development.d.ts

@@ -1,16 +0,0 @@
-import { Effect } from "effect";
-import type { ClientCore } from "./core.ts";
-import type { NavigationOwner } from "./navigation.ts";
-declare global {
-    interface Window {
-        __vorma_development?: {
-            readonly revalidateFn: () => Promise<void>;
-            readonly updateModuleFn: (url: string, module: Readonly<Record<string, unknown>>) => void;
-        };
-    }
-}
-/** Applies accepted view updates through the existing frame publication and service lifetimes. */
-export declare function installDevelopmentUpdates(input: {
-    readonly core: ClientCore;
-    readonly navigation: NavigationOwner;
-}): Effect.Effect<void, never, never>;

package/dist/client/document-recovery.d.ts

@@ -1,4 +0,0 @@
-import type { Cause } from "effect";
-import type { ClientCore } from "./core.ts";
-/** Loads the browser's current URL as a document after client navigation cannot complete. */
-export declare function reloadDocument(core: Pick<ClientCore, "getState" | "updateState" | "publishEvent">, cause: Cause.Cause<unknown>): void;

package/dist/client/endpoints.d.ts

@@ -1,54 +0,0 @@
-import { Effect } from "effect";
-import { Headers } from "effect/unstable/http";
-import { type RedirectStatus } from "../universal/protocol-schemas.ts";
-import type { EndpointCallInput } from "./contracts.ts";
-import type { ClientCore } from "./core.ts";
-import { BuildMismatchError, CancelledByDedupeKeyError, HandlerError, InputError, NavigationError, RevalidationError, TransportError } from "./errors.ts";
-import type { NavigationResult, OperationId, RevalidationResult } from "./types.ts";
-export type ResponseMetadata = {
-    readonly status: number;
-    readonly headers: Headers.Headers;
-};
-export type QueryResponse<A> = {
-    readonly data: A;
-    readonly responseMetadata: ResponseMetadata;
-};
-export type EndpointRevalidation = Effect.Effect<RevalidationResult, RevalidationError>;
-export type MutationSettlement<A> = {
-    readonly _tag: "Completed";
-    readonly operationId: OperationId;
-    readonly data: A;
-    readonly responseMetadata: ResponseMetadata;
-    readonly revalidation: EndpointRevalidation;
-} | {
-    readonly _tag: "Redirected";
-    readonly operationId: OperationId;
-    readonly redirectUrl: string;
-    /** The status the server intended; `undefined` when the browser followed the redirect itself, so the client never saw it. */
-    readonly redirectStatus: RedirectStatus | undefined;
-    readonly responseMetadata: ResponseMetadata;
-    readonly revalidation: EndpointRevalidation;
-};
-export type EndpointFrameworkError = InputError | CancelledByDedupeKeyError | BuildMismatchError | TransportError | HandlerError;
-/** What the endpoint path needs from navigation and freshness. */
-export type EndpointDependencies = {
-    /** Registers a demand and returns the observation of that registered demand. */
-    readonly requireRefreshFn: (input: {
-        readonly skipWorkIndicator: boolean;
-    }) => EndpointRevalidation;
-    /** Starts a replace navigation to a same-origin redirect target and observes it. */
-    readonly redirectFn: (url: URL) => Effect.Effect<NavigationResult, NavigationError>;
-    readonly navigateDocumentFn: (href: string) => void;
-    readonly retireReusableFn: () => void;
-};
-export type DispatchFacts = {
-    readonly sequence: number;
-    readonly generation: number;
-};
-export type EndpointOperations = {
-    readonly query: (input: EndpointCallInput) => Effect.Effect<QueryResponse<unknown>, unknown>;
-    /** A query read that reports its dispatch sequence, for freshness acknowledgment. */
-    readonly read: (input: EndpointCallInput, reportDispatchFn: ((facts: DispatchFacts) => void) | undefined) => Effect.Effect<QueryResponse<unknown>, unknown>;
-    readonly mutate: (input: EndpointCallInput) => Effect.Effect<MutationSettlement<unknown>, unknown>;
-};
-export declare function createEndpointOperations(core: Pick<ClientCore, "updateState" | "getState" | "publishEvent" | "getClientBuildId" | "getDeploymentId" | "reportBuildMismatch" | "prepareRequest" | "provideClient" | "advanceSequence" | "getGenerationRetirement" | "activations" | "mutationFibers">, dependencies: EndpointDependencies): EndpointOperations;

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;