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

package/dist/server/public-assets.d.ts

@@ -1,18 +0,0 @@
-import { Effect } from "effect";
-import * as Path from "effect/Path";
-import type { PlatformError } from "effect/PlatformError";
-import * as HttpPlatform from "effect/unstable/http/HttpPlatform";
-import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
-import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
-import type { Application } from "./index.ts";
-import { type VormaStartupError } from "./runtime/startup-error.ts";
-/**
- * Serves the build's public directory from the process filesystem. Requests for
- * URLs outside the published set, and every other method than `GET` and `HEAD`,
- * continue to the host's own router. The host passes its explicitly assembled
- * application so that this constructor can read the build metadata. The caller
- * explicitly registers the returned middleware through the host router.
- */
-export declare function makePublicAssetsFileMiddleware(input: {
-    readonly app: Application;
-}): Effect.Effect<<E, R>(httpEffect: Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>) => Effect.Effect<HttpServerResponse.HttpServerResponse, E | import("./development/metadata.ts").DevelopmentMetadataIssue | PlatformError | VormaStartupError, R | HttpServerRequest.HttpServerRequest>, VormaStartupError, HttpPlatform.HttpPlatform | Path.Path>;

package/dist/server/runtime/application.d.ts

@@ -1,15 +0,0 @@
-import { Context, Effect, Layer } from "effect";
-import { type ProductionMetadata } from "../../universal/protocol.ts";
-import type { VormaConfig } from "../config/index.ts";
-import type { DevelopmentMetadataIssue } from "../development/metadata.ts";
-import type { RegisterableDeclaration } from "../index.ts";
-import { type VormaStartupError } from "./startup-error.ts";
-export type CompiledApplication = {
-    readonly registeredDeclarations: ReadonlyArray<RegisterableDeclaration>;
-    readonly metadata: ProductionMetadata;
-    readonly readDevelopmentMetadata?: Effect.Effect<ProductionMetadata, DevelopmentMetadataIssue>;
-};
-export declare const ApplicationRuntime: Context.Service<CompiledApplication, CompiledApplication>;
-export declare const APPLICATION_RUNTIME: unique symbol;
-/** One shared acquisition for an application's compiled registration and asset metadata. */
-export declare function makeApplicationRuntime(config: VormaConfig): Layer.Layer<CompiledApplication, VormaStartupError>;

package/dist/server/runtime/assets.d.ts

@@ -1,15 +0,0 @@
-import type { ClientModule } from "../../universal/protocol.ts";
-/** Ordered, deduplicated asset URLs for a document and subsequent navigation. */
-export type PreparedAssets = {
-    readonly navigationDepUrls: ReadonlyArray<string>;
-    readonly navigationCssBundleUrls: ReadonlyArray<string>;
-    readonly documentDepUrls: ReadonlyArray<string>;
-    readonly documentCssBundleUrls: ReadonlyArray<string>;
-    readonly navigationStaticAssetUrls: ReadonlyArray<string>;
-    readonly documentStaticAssetUrls: ReadonlyArray<string>;
-};
-/** Combines static module metadata without running application code. */
-export declare function prepareAssets(input: {
-    readonly clientEntry: ClientModule;
-    readonly views: ReadonlyArray<ClientModule | null>;
-}): PreparedAssets;

package/dist/server/runtime/context.d.ts

@@ -1,96 +0,0 @@
-import { Effect, Ref } from "effect";
-import * as Cookies from "effect/unstable/http/Cookies";
-import type * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
-import type { ProductionMetadata } from "../../universal/protocol.ts";
-import type { Element } from "../document.ts";
-import type { RedirectStatus, ResponseEffects } from "./effects.ts";
-declare const ResponseInputError_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]; }>) => import("effect/Cause").YieldableError & {
-    readonly _tag: "ResponseInputError";
-} & Readonly<A>;
-export declare class ResponseInputError extends ResponseInputError_base<{
-    readonly operation: "expireCookie" | "redirectToPattern";
-    readonly message: string;
-    readonly cause: unknown;
-}> {
-}
-type IncomingRequestFacts = {
-    readonly request: HttpServerRequest.HttpServerRequest;
-    /** The build the browser runtime is running, when the request came from it. */
-    readonly clientBuildId: string | undefined;
-    readonly getCookie: (name: string) => string | undefined;
-    /** The hashed URL of a public asset by its source key. A leading slash is optional. */
-    readonly getPublicUrl: (key: string) => string;
-};
-export type RequestFacts<Pattern extends string, Params, Input> = IncomingRequestFacts & {
-    readonly pattern: Pattern;
-    readonly params: Params;
-    readonly splatValues: ReadonlyArray<string>;
-    readonly input: Input;
-};
-export type MiddlewareRequestFacts = IncomingRequestFacts;
-export type ResponseOps = {
-    readonly setStatus: (status: number) => Effect.Effect<void>;
-    readonly setHeader: (options: {
-        readonly name: string;
-        readonly value: string;
-    }) => Effect.Effect<void>;
-    readonly appendHeader: (options: {
-        readonly name: string;
-        readonly value: string;
-    }) => Effect.Effect<void>;
-    readonly setCookie: (cookie: Cookies.Cookie) => Effect.Effect<void>;
-    readonly expireCookie: (options: {
-        readonly name: string;
-        readonly path?: string;
-        readonly domain?: string;
-    }) => Effect.Effect<void, ResponseInputError>;
-    /** Ends the response with a redirect to a URL. A request carrying the client-redirect acceptance header receives it as data; anything else gets the status. */
-    readonly redirectToUrl: (options: {
-        readonly url: string | URL;
-        readonly status: RedirectStatus;
-    }) => Effect.Effect<never>;
-    /** Ends the response with a redirect to one of the application's own patterns. */
-    readonly redirectToPattern: (options: {
-        readonly pattern: string;
-        readonly params?: Readonly<Record<string, string>>;
-        readonly splatValues?: ReadonlyArray<string>;
-        readonly input?: unknown;
-        readonly hash?: string;
-        readonly status: RedirectStatus;
-    }) => Effect.Effect<never, ResponseInputError>;
-};
-export type HeadOps = {
-    readonly setTitle: (title: string) => Effect.Effect<void>;
-    readonly setDescription: (description: string) => Effect.Effect<void>;
-    readonly addMeta: (attributes: Readonly<Record<string, string>>) => Effect.Effect<void>;
-    /** Collects plain head elements for ordered response composition. */
-    readonly addHead: (elements: ReadonlyArray<Element>) => Effect.Effect<void>;
-};
-export type RequestSource = {
-    readonly request: HttpServerRequest.HttpServerRequest;
-    readonly clientBuildId: string | undefined;
-    readonly acceptsClientRedirect: boolean;
-    readonly metadata: ProductionMetadata;
-};
-export declare function makeIncomingRequestFacts(source: RequestSource): IncomingRequestFacts;
-export declare function makeRequestFacts<Pattern extends string, Params, Input>(source: RequestSource, facts: {
-    readonly pattern: Pattern;
-    readonly params: Params;
-    readonly splatValues: ReadonlyArray<string>;
-    readonly input: Input;
-}): RequestFacts<Pattern, Params, Input>;
-/** A UI route target resolved against the plan: its authored pattern and its validated search record, if any. */
-export type ResolvedRouteTarget = {
-    readonly pattern: string;
-    readonly search: unknown;
-};
-export declare function makeResponseOps(input: {
-    readonly effects: Ref.Ref<ResponseEffects>;
-    readonly acceptsClientRedirect: boolean;
-    readonly resolveRouteTargetFn: (options: {
-        readonly pattern: string;
-        readonly search: unknown;
-    }) => Effect.Effect<ResolvedRouteTarget, unknown>;
-}): ResponseOps;
-export declare function makeHeadOps(effects: Ref.Ref<ResponseEffects>): HeadOps;
-export {};

package/dist/server/runtime/domain-errors.d.ts

@@ -1,11 +0,0 @@
-import { type TransportedValue } from "../../universal/value-transport.ts";
-import type { EndpointErrorDeclaration } from "../graph/declarations.ts";
-export type MatchedDeclaredError = {
-    readonly tag: string;
-    readonly status: number;
-    readonly data: TransportedValue;
-};
-export declare function matchDeclaredError(input: {
-    readonly errors: ReadonlyArray<EndpointErrorDeclaration>;
-    readonly value: unknown;
-}): MatchedDeclaredError | undefined;

package/dist/server/runtime/effects.d.ts

@@ -1,83 +0,0 @@
-import * as Cookies from "effect/unstable/http/Cookies";
-import type { RedirectStatus } from "../../universal/protocol-schemas.ts";
-import type { TransportedValue } from "../../universal/value-transport.ts";
-import type { Element } from "../document.ts";
-export type HeaderOp = {
-    readonly kind: "set" | "append";
-    readonly name: string;
-    readonly value: string;
-};
-/** A cookie as Effect's HTTP layer represents it, already validated by `Cookies.makeCookie`. */
-export type Cookie = Cookies.Cookie;
-export type { RedirectStatus } from "../../universal/protocol-schemas.ts";
-export type Terminal = {
-    readonly _tag: "Redirect";
-    readonly location: string;
-    readonly status: RedirectStatus;
-    /** The client runtime asked to perform the redirect itself: 200 plus a header instead of a 3xx. */
-    readonly client: boolean;
-} | {
-    readonly _tag: "Error";
-    readonly status: number;
-    readonly text: string;
-    /** A matched declared domain failure: its tag and its fields, transported by value. */
-    readonly domain?: {
-        readonly tag: string;
-        readonly data: TransportedValue;
-    } | undefined;
-};
-export type ResponseEffects = {
-    readonly status: number | null;
-    readonly terminal: Terminal | null;
-    readonly headerOps: ReadonlyArray<HeaderOp>;
-    readonly cookies: Cookies.Cookies;
-    readonly headElements: ReadonlyArray<Element>;
-};
-export type TerminalResponseEffects = ResponseEffects & {
-    readonly terminal: Terminal;
-};
-export declare const empty: ResponseEffects;
-/** Whether these effects end the response for everything after them. */
-export declare function endsResponse(effects: ResponseEffects): effects is TerminalResponseEffects;
-export declare function mergeResponseEffects(input: {
-    readonly earlier: ResponseEffects;
-    readonly later: ResponseEffects;
-}): ResponseEffects;
-export declare function setStatus(input: {
-    readonly effects: ResponseEffects;
-    readonly status: number;
-}): ResponseEffects;
-export declare function setHeader(input: {
-    readonly effects: ResponseEffects;
-    readonly name: string;
-    readonly value: string;
-}): ResponseEffects;
-export declare function appendHeader(input: {
-    readonly effects: ResponseEffects;
-    readonly name: string;
-    readonly value: string;
-}): ResponseEffects;
-export declare function setCookie(input: {
-    readonly effects: ResponseEffects;
-    readonly cookie: Cookie;
-}): ResponseEffects;
-export declare function appendHeadElements(input: {
-    readonly effects: ResponseEffects;
-    readonly elements: ReadonlyArray<Element>;
-}): ResponseEffects;
-export declare function setRedirect(input: {
-    readonly effects: ResponseEffects;
-    readonly location: string;
-    readonly status: RedirectStatus;
-    readonly client: boolean;
-}): ResponseEffects;
-/** Made by the execute program from a handler's error, never by a handler. */
-export declare function setTerminalError(input: {
-    readonly effects: ResponseEffects;
-    readonly status: number;
-    readonly text: string;
-    readonly domain?: {
-        readonly tag: string;
-        readonly data: TransportedValue;
-    } | undefined;
-}): TerminalResponseEffects;

package/dist/server/runtime/execute.d.ts

@@ -1,13 +0,0 @@
-import { Effect, type Scope } from "effect";
-import type { TransportedValue } from "../../universal/value-transport.ts";
-import * as Effects from "./effects.ts";
-import { type HandlerOutput, type Invocation, type TerminalOutcome, type UiExecutionInput, type UiExecutionReport, type UiRoute } from "./handler.ts";
-export declare function executeEndpoint<Services>(input: {
-    readonly effects: Effects.ResponseEffects;
-    readonly endpoint: Invocation<TransportedValue, Services>;
-}): Effect.Effect<HandlerOutput<TransportedValue>, never, Services | Scope.Scope>;
-export declare function executeUi<Services>(input: {
-    readonly effects: Effects.ResponseEffects;
-    readonly positions: ReadonlyArray<UiExecutionInput<Services>>;
-}): Effect.Effect<UiExecutionReport<UiRoute> | TerminalOutcome, never, Services | Scope.Scope>;
-export declare function executeMiddleware<Services>(invocations: ReadonlyArray<Invocation<void, Services>>): Effect.Effect<HandlerOutput<void>, never, Services | Scope.Scope>;

package/dist/server/runtime/finalize.d.ts

@@ -1,44 +0,0 @@
-import { Result } from "effect";
-import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
-import type { ResponseEffects } from "./effects.ts";
-export type FrameworkOwnedHeaderError = {
-    readonly _tag: "FrameworkOwnedHeader";
-    readonly name: string;
-};
-export type FinalizeError = FrameworkOwnedHeaderError;
-/** A navigation's JSON payload response with its application or conservative cache policy. */
-export declare function finalizeJson(input: {
-    readonly json: string;
-    readonly effects: ResponseEffects;
-    readonly clientBuildId: string;
-}): Result.Result<HttpServerResponse.HttpServerResponse, FinalizeError>;
-/** A first load's HTML response with its application or conservative cache policy. */
-export declare function finalizeHtml(input: {
-    readonly html: string;
-    readonly effects: ResponseEffects;
-    readonly clientBuildId: string;
-}): Result.Result<HttpServerResponse.HttpServerResponse, FinalizeError>;
-/** An endpoint's JSON response. No cache-control is assumed for endpoints. */
-export declare function finalizeEndpointJson(input: {
-    readonly json: string;
-    readonly effects: ResponseEffects;
-    readonly clientBuildId: string;
-}): Result.Result<HttpServerResponse.HttpServerResponse, FinalizeError>;
-/** An endpoint redirect, or its structured public handler rejection. */
-export declare function finalizeEndpointTerminal(input: {
-    readonly effects: ResponseEffects;
-    readonly clientBuildId: string;
-}): Result.Result<HttpServerResponse.HttpServerResponse, FinalizeError>;
-/** A response that ended before any body was produced: a redirect or an error. */
-export declare function finalizeTerminal(input: {
-    readonly effects: ResponseEffects;
-    readonly clientBuildId: string;
-}): Result.Result<HttpServerResponse.HttpServerResponse, FinalizeError>;
-/** The answer to a client whose build does not match the server's. */
-export declare function finalizeBuildSkew(clientBuildId: string): HttpServerResponse.HttpServerResponse;
-/** A plain-text response for a Vorma protocol or execution failure. */
-export declare function finalizeStatus(input: {
-    readonly status: number;
-    readonly text: string;
-    readonly clientBuildId: string;
-}): HttpServerResponse.HttpServerResponse;

package/dist/server/runtime/handler.d.ts

@@ -1,106 +0,0 @@
-import { Cause, Effect, type Result } from "effect";
-import type { TransportedValue } from "../../universal/value-transport.ts";
-import type { ResponseEffects, TerminalResponseEffects } from "./effects.ts";
-import type { UiPosition } from "./plan.ts";
-export type HandlerRole = "middleware" | "uiLoader" | "endpoint";
-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>;
-/**
- * How any handler fails on purpose. In a UI loader: the response carries the
- * status and public message without the failed route's metadata or module.
- * An available ancestor boundary or the application boundary renders the error.
- * In an endpoint or
- * task middleware: the response is the status and the message. `cause` never
- * leaves the server.
- */
-export declare class HandlerError extends HandlerError_base<{
-    readonly status: number;
-    readonly clientMessage?: string;
-    readonly cause?: unknown;
-}> {
-}
-/**
- * A declared domain failure on its way to the wire. A `HandlerError` with
- * the encoded domain payload beside it, so the execute program keeps its
- * single error channel while the response keeps the tag and data a generic
- * rejection cannot carry. Constructed only by the endpoint runner after it
- * matched the thrown value against the declaration's error schemas.
- */
-export declare class DeclaredDomainError extends HandlerError {
-    readonly tag: string;
-    readonly data: TransportedValue;
-    constructor(input: {
-        readonly status: number;
-        readonly clientMessage?: string;
-        readonly tag: string;
-        readonly data: TransportedValue;
-    });
-}
-/** The public message for a status the application did not explain. */
-export declare function getStatusText(status: number): string;
-/** Ends a handler without exposing private control flow in its error channel. */
-export declare const interruptHandler: Effect.Effect<never>;
-export declare function matchesHandlerEndInterruption(cause: Cause.Cause<unknown>): boolean;
-export type TerminalOutcome = {
-    readonly _tag: "Terminal";
-    readonly effects: TerminalResponseEffects;
-};
-export type HandlerOutput<Value> = {
-    readonly _tag: "Continue";
-    readonly effects: ResponseEffects;
-    readonly data: Value;
-} | TerminalOutcome;
-export type Invocation<Value, Services> = {
-    readonly id: string;
-    readonly role: HandlerRole;
-    readonly pattern: string;
-    readonly run: Effect.Effect<InvocationOutcome<Value>, unknown, Services>;
-};
-/** A failure stops later invocations but retains this invocation's recorded response operations. */
-export type InvocationOutcome<Value> = HandlerOutput<Value> | {
-    readonly _tag: "Failed";
-    readonly effects: ResponseEffects;
-    readonly cause: Cause.Cause<unknown>;
-};
-/** A matched position and its parsed search; parsing failure belongs to its loader. */
-export type UiRoute = {
-    readonly position: UiPosition;
-    readonly searchInput: Result.Result<unknown, HandlerError> | null;
-};
-export type UiExecutionInput<Services> = {
-    readonly owner: UiRoute;
-    readonly invocation: Invocation<TransportedValue, Services> | null;
-};
-/** A successful position retains its original owner and required data. */
-export type CompletedPosition<Owner, Value> = {
-    readonly _tag: "NoHandler";
-    readonly owner: Owner;
-} | {
-    readonly _tag: "Completed";
-    readonly owner: Owner;
-    readonly data: Value;
-};
-export type UiExecutionPosition<Owner> = CompletedPosition<Owner, TransportedValue> | {
-    readonly _tag: "Failed";
-    readonly owner: Owner;
-    readonly error: ServerError;
-} | {
-    readonly _tag: "Suppressed";
-    readonly owner: Owner;
-};
-export type UiExecutionReport<Owner> = {
-    readonly _tag: "Ui";
-    readonly effects: ResponseEffects;
-    readonly positions: ReadonlyArray<UiExecutionPosition<Owner>>;
-};
-/** A UI loader failed; the page still renders, from this segment's error boundary down. */
-export type ServerError = {
-    readonly id: string;
-    readonly pattern: string;
-    /** Index into the complete matched UI chain, outermost first. */
-    readonly index: number;
-    readonly status: number;
-    readonly clientMessage: string;
-};
-export {};

package/dist/server/runtime/head.d.ts

@@ -1,22 +0,0 @@
-import type { Element } from "../document.ts";
-import type { HeadDeduplicationRule } from "../graph/declarations.ts";
-/** The built-in identities. An element matches a rule when its tag matches and every listed attribute matches; `true` means present with any value. */
-export declare const defaultDedupeRules: ReadonlyArray<HeadDeduplicationRule>;
-export type PreparedHead = {
-    readonly title: Element | null;
-    readonly meta: ReadonlyArray<Element>;
-    readonly rest: ReadonlyArray<Element>;
-};
-type CompiledHeadRule = {
-    readonly index: number;
-    readonly attributes: ReadonlyArray<readonly [string, string | true]>;
-};
-export type CompiledHeadRules = ReadonlyMap<string, ReadonlyArray<CompiledHeadRule>>;
-/** Normalizes the application's static rules once, preserving priority within each tag. */
-export declare function compileHeadRules(rules: ReadonlyArray<HeadDeduplicationRule>): CompiledHeadRules;
-/** Deduplicates managed defaults and ordered contributions before classification. */
-export declare function prepareHead(input: {
-    readonly elements: ReadonlyArray<Element>;
-    readonly rules: CompiledHeadRules;
-}): PreparedHead;
-export {};

package/dist/server/runtime/payload.d.ts

@@ -1,50 +0,0 @@
-import { Result } from "effect";
-import type { HeadElementWire, NavigationPayload, RoutePayloadWire, SsrPayload } from "../../universal/protocol-schemas.ts";
-import type { ClientModule } from "../../universal/protocol.ts";
-import type { TransportedValue } from "../../universal/value-transport.ts";
-import { type Element, type RenderError } from "../document.ts";
-import { type PreparedAssets } from "./assets.ts";
-import type { UiExecutionReport } from "./handler.ts";
-import { type PreparedHead, type CompiledHeadRules } from "./head.ts";
-import type { UiPosition } from "./plan.ts";
-export type HeadRenderError = {
-    readonly _tag: "HeadRender";
-    readonly tag: string;
-    readonly reason: RenderError;
-};
-/** One matched position and the search its loader read; null when the route has no search contract or the parse failed, which the report records as that position's error. */
-export type UiRouteInput = {
-    readonly position: UiPosition;
-    readonly searchInput: TransportedValue | null;
-};
-export type PayloadProjection = {
-    readonly route: RoutePayloadWire;
-    readonly preparedHead: PreparedHead;
-} & PreparedAssets;
-export declare function projectPayload(input: {
-    readonly clientEntry: ClientModule;
-    readonly assets: PreparedAssets;
-    readonly report: UiExecutionReport<UiRouteInput>;
-    /** The document's authored head elements, the overridable defaults. */
-    readonly headDefaults: ReadonlyArray<Element>;
-    readonly dedupeRules: CompiledHeadRules;
-}): PayloadProjection;
-export declare function toNavigationPayload(projection: PayloadProjection): Result.Result<NavigationPayload, HeadRenderError>;
-export declare function toSsrPayload(input: {
-    readonly projection: PayloadProjection;
-    readonly clientBuildId: string;
-    readonly isDev: boolean;
-    readonly deploymentId: string | undefined;
-}): SsrPayload;
-/** The deduped head for a response, with later contributions replacing the first position of each identity. */
-export declare function prepareHeadOf(input: {
-    readonly report: UiExecutionReport<UiRouteInput>;
-    readonly headDefaults: ReadonlyArray<Element>;
-    readonly dedupeRules: CompiledHeadRules;
-}): PreparedHead;
-/**
- * A head element on the wire: raw attribute values, which the client sets
- * through the DOM, and escaped text or trusted HTML, which the client sets
- * as inner HTML. The initial document uses the same serialization.
- */
-export declare function toWireHeadElement(element: Element): Result.Result<HeadElementWire, HeadRenderError>;

package/dist/server/runtime/pipeline.d.ts

@@ -1,27 +0,0 @@
-import { TaskContext, TaskRuntime } from "@vorma/primitives/tasks";
-import { Context, Effect, Layer, type Scope } from "effect";
-import type * as FileSystem from "effect/FileSystem";
-import type * as Path from "effect/Path";
-import { HttpServerError, type Multipart } from "effect/unstable/http";
-import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
-import type * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
-import { type ProductionMetadata } from "../../universal/protocol.ts";
-import { type Plan, type RequestOperation } from "./plan.ts";
-export type ServiceKind = "document" | "uiLoaders" | "queries" | "mutations" | "streams" | "middleware";
-/** The services the host built for the document and each handler kind. */
-export type KindServices = Readonly<Record<ServiceKind, Context.Context<never>>>;
-export type PipelineInput = {
-    readonly plan: Plan;
-    readonly operation: RequestOperation;
-    readonly metadata: ProductionMetadata;
-    readonly request: HttpServerRequest.HttpServerRequest;
-    readonly services: KindServices;
-    readonly isDev: boolean;
-    readonly deploymentId?: string;
-};
-export declare function handleRequest<RequestServices = never, RequestError = never, RequestRequirements = never>(input: PipelineInput & {
-    readonly requestServices?: Layer.Layer<RequestServices, RequestError, RequestRequirements>;
-}): Effect.Effect<HttpServerResponse.HttpServerResponse, BodyError | HttpServerError.HttpServerError | RequestError, BodyServices | TaskContext | TaskRuntime | RequestRequirements | Scope.Scope>;
-type BodyServices = FileSystem.FileSystem | Path.Path | Scope.Scope;
-type BodyError = HttpServerError.HttpServerError | Multipart.MultipartError;
-export {};

package/dist/server/runtime/plan.d.ts

@@ -1,98 +0,0 @@
-import { type CompiledNestedPattern, type FlatMatcher, type FlatValueMatcher, type NestedValueMatcher, type PatternCompileError } from "@vorma/primitives/matcher";
-import { Result } from "effect";
-import { type PathWireError } from "../../universal/path-wire.ts";
-import type { ClientModule, ClientViewModule } from "../../universal/protocol.ts";
-import { type EndpointNode, type GraphError, type MiddlewareNode, type UiLoaderNode, type UiSearchOwner } from "../graph/compile.ts";
-import type { HtmlDocumentDeclaration, HttpMethod, EndpointDeclaration, TaskMiddlewareDeclaration, UiLoaderDeclaration } from "../graph/declarations.ts";
-import { type PreparedAssets } from "./assets.ts";
-import { type CompiledHeadRules } from "./head.ts";
-export type MiddlewareEntry = {
-    readonly node: MiddlewareNode;
-    readonly matcher: FlatMatcher;
-};
-export type UiNode = {
-    /** The logical authored identity exposed to application and browser code. */
-    readonly pattern: string;
-    readonly registered: CompiledNestedPattern;
-    readonly uiLoader: UiLoaderNode | null;
-    readonly searchOwners: ReadonlyArray<UiSearchOwner>;
-    readonly clientViewModule: ClientViewModule | null;
-};
-/** One matched UI position: its node and the captures its own pattern names. */
-export type UiPosition = {
-    readonly node: UiNode;
-    /** The parameters this position's pattern names, decoded. */
-    readonly params: Readonly<Record<string, string>>;
-    /** The segments this position's splat captured, decoded; empty without one. */
-    readonly splatValues: ReadonlyArray<string>;
-};
-export type Plan = {
-    readonly clientEntry: ClientModule;
-    /** Contains structural preparation only, never request execution or results. */
-    readonly preparedRequests: Map<string, Result.Result<RequestPreparation, PathWireError>>;
-    readonly document: HtmlDocumentDeclaration;
-    /** The built-in head identities followed by the document's own, in authored order. */
-    readonly headDeduplicationRules: CompiledHeadRules;
-    readonly uiMatcher: NestedValueMatcher<UiNode>;
-    /** UI positions by authored identity, for application-authored targets. */
-    readonly uiByAuthoredPattern: ReadonlyMap<string, UiNode>;
-    readonly endpoints: ReadonlyMap<HttpMethod, FlatValueMatcher<EndpointNode>>;
-    readonly middleware: ReadonlyArray<MiddlewareEntry>;
-};
-export type PlanError = {
-    readonly _tag: "PlanError";
-    readonly cause: PatternCompileError | PathWireError;
-};
-/** Compiles application declarations and server-side view metadata into request matchers. */
-export declare function compileRequestPlan(input: {
-    readonly clientEntry: ClientModule;
-    readonly document: HtmlDocumentDeclaration;
-    readonly handlers: ReadonlyArray<UiLoaderDeclaration | EndpointDeclaration>;
-    readonly middleware: ReadonlyArray<TaskMiddlewareDeclaration>;
-    readonly clientViews: Readonly<Record<string, ClientViewModule>>;
-}): Result.Result<Plan, PlanError | ReadonlyArray<GraphError>>;
-/** The application selects the operation when mounting its native handler. */
-export type RequestOperation = {
-    readonly _tag: "Ui";
-} | {
-    readonly _tag: "Endpoint";
-    readonly method: HttpMethod;
-};
-export type Target = {
-    readonly _tag: "Endpoint";
-    readonly node: EndpointNode;
-    readonly params: Readonly<Record<string, string>>;
-    readonly splatValues: ReadonlyArray<string>;
-} | {
-    readonly _tag: "Ui";
-    /** Outermost to innermost. */
-    readonly positions: ReadonlyArray<UiPosition>;
-    readonly assets: PreparedAssets;
-} | {
-    readonly _tag: "NotFound";
-};
-export type RequestPreparation = {
-    readonly target: Target;
-    readonly middleware: ReadonlyArray<MiddlewareNode>;
-};
-/** Bounds retained pathname preparation across every operation in one plan. */
-export declare const REQUEST_PREPARATION_CAPACITY = 4096;
-/** Reuses only operation/pathname-derived data within this compiled application. */
-export declare function getRequestPreparation(input: {
-    readonly plan: Plan;
-    readonly operation: RequestOperation;
-    /** Canonical matcher-wire pathname, without a query string. */
-    readonly path: string;
-}): Result.Result<RequestPreparation, PathWireError>;
-export declare function classifyRequest(input: {
-    readonly plan: Plan;
-    readonly operation: RequestOperation;
-    /** Canonical matcher-wire pathname. */
-    readonly path: string;
-}): Result.Result<Target, PathWireError>;
-/** Selects task middleware for the mounted operation, in declaration order. */
-export declare function getMiddlewareFor(input: {
-    readonly plan: Plan;
-    readonly method: string;
-    readonly path: string;
-}): ReadonlyArray<MiddlewareNode>;

package/dist/server/runtime/render-document.d.ts

@@ -1,16 +0,0 @@
-import { Result } from "effect";
-import { type RenderError } from "../document.ts";
-import type { DocumentAttributes } from "../graph/declarations.ts";
-import type { PreparedHead } from "./head.ts";
-/** Serializes the fixed document structure after head deduplication and classification. */
-export declare function renderDocument(input: {
-    readonly attributes: DocumentAttributes;
-    readonly prepared: PreparedHead;
-    readonly criticalCss: string;
-    readonly developmentHeadHtml?: string;
-    readonly cssBundleUrls: ReadonlyArray<string>;
-    readonly modulePreloadUrls: ReadonlyArray<string>;
-    readonly staticAssetUrls: ReadonlyArray<string>;
-    readonly entryImportUrl: string;
-    readonly payloadJson: string;
-}): Result.Result<string, RenderError>;

package/dist/server/runtime/startup-error.d.ts

@@ -1,11 +0,0 @@
-export type VormaStartupError = {
-    readonly _tag: "VormaStartupError";
-    readonly operation: "loadApplicationRuntime" | "resolvePublicAssetDirectory" | "resolvePublicAssetFile" | "readDeploymentConfiguration" | "validateApplicationGraph" | "buildRequestPlan";
-    readonly message: string;
-    readonly cause?: unknown;
-};
-export declare function createVormaStartupError(input: {
-    readonly operation: VormaStartupError["operation"];
-    readonly message: string;
-    readonly cause?: unknown;
-}): VormaStartupError;

package/dist/server/runtime/transport-type-entries.d.ts

@@ -1,2 +0,0 @@
-import type { TransportTypeEntry } from "../../universal/value-transport.ts";
-export declare const SERVER_TRANSPORT_TYPE_ENTRIES: ReadonlyArray<TransportTypeEntry>;

package/dist/server/runtime/vercel-deployment.d.ts

@@ -1,2 +0,0 @@
-import { Config, Effect } from "effect";
-export declare const getVercelDeploymentId: Effect.Effect<string | undefined, Config.ConfigError, never>;