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

package/dist/server/graph/declarations.d.ts

@@ -1,117 +0,0 @@
-import type { Effect, Schema, Stream } from "effect";
-import type * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
-import type { HttpMethod } from "../../universal/http-method.ts";
-import type { Attributes, Element } from "../document.ts";
-/** A native schema; constructors retain the services required by executed codec operations. */
-export type DeclaredSchema = Schema.Codec<unknown, unknown, unknown, unknown>;
-/**
- * A handler with its context type erased. The public constructors type the
- * context per kind; the request pipeline builds that context and calls the
- * function with it. The failure and requirement types are erased too: the
- * failure is read back when the handler settles, and `Vorma.makeHandlers`
- * requires the host to supply the services of every handler kind.
- */
-export type HandlerFn = (context: never) => Effect.Effect<unknown, unknown, unknown>;
-/** A stream handler with its context type erased, as `HandlerFn`. */
-export type StreamHandlerFn = (context: never) => Stream.Stream<unknown, unknown, unknown>;
-export type UiLoaderDeclaration = {
-    readonly _tag: "UiLoader";
-    readonly pattern: string;
-    /** Schema of the URL search parameters. Absent means the segment takes none. */
-    readonly input: DeclaredSchema | undefined;
-    readonly output: DeclaredSchema;
-    readonly fn: HandlerFn;
-};
-export type EndpointKind = "query" | "mutation" | "stream";
-/**
- * Where an endpoint's input arrives, read from its method and input schema.
- * A GET reads the URL's search parameters. Any other method reads its body,
- * parsed as a form when the input schema is `FormData` or derives from it,
- * and as JSON otherwise.
- */
-export type InputTransport = {
-    readonly kind: "none";
-} | {
-    readonly kind: "search";
-    readonly schema: DeclaredSchema;
-} | {
-    readonly kind: "json";
-    readonly schema: DeclaredSchema;
-} | {
-    readonly kind: "formData";
-    readonly schema: DeclaredSchema;
-};
-export declare function getInputTransport(declaration: {
-    readonly method: HttpMethod;
-    readonly input: DeclaredSchema | undefined;
-}): InputTransport;
-/**
- * One declared application failure: the schema its thrown values encode
- * with, and the explicit HTTP status the rejection carries. Queries and
- * mutations declare these; the build links each schema to its authored
- * export, and the runtime encodes matching failures on the way out.
- */
-export type EndpointErrorDeclaration = {
-    readonly schema: DeclaredSchema;
-    readonly status: number;
-};
-type EndpointDeclarationBase = {
-    readonly _tag: "Endpoint";
-    readonly method: HttpMethod;
-    readonly pattern: string;
-    readonly input: DeclaredSchema | undefined;
-    /** Declared application failures of a query or mutation. Empty for a stream. */
-    readonly errors: ReadonlyArray<EndpointErrorDeclaration>;
-};
-/** A query or mutation: one response, encoded through `output`. */
-export type ResponseEndpointDeclaration = EndpointDeclarationBase & {
-    readonly kind: "query" | "mutation";
-    readonly output: DeclaredSchema;
-    readonly event: undefined;
-    readonly fn: HandlerFn;
-};
-/** A stream: a sequence of events, each encoded through `event`. */
-export type StreamEndpointDeclaration = EndpointDeclarationBase & {
-    readonly kind: "stream";
-    readonly output: undefined;
-    readonly event: DeclaredSchema;
-    readonly fn: StreamHandlerFn;
-};
-export type EndpointDeclaration = ResponseEndpointDeclaration | StreamEndpointDeclaration;
-export type { HttpMethod } from "../../universal/http-method.ts";
-export type TaskMiddlewareDeclaration = {
-    readonly _tag: "TaskMiddleware";
-    readonly patterns: ReadonlyArray<string>;
-    readonly methods: ReadonlyArray<HttpMethod>;
-    readonly fn: HandlerFn;
-};
-export type HtmlDocumentContext = {
-    readonly request: HttpServerRequest.HttpServerRequest;
-    readonly clientBuildId: string | undefined;
-    readonly getCookie: (name: string) => string | undefined;
-    readonly getPublicUrl: (key: string) => string;
-};
-/**
- * One head identity beyond the built-in rules: elements with this tag whose
- * listed attributes match occupy one slot, and a later contribution replaces
- * the earlier one. A string requires that exact value; `true` requires the
- * attribute to be present with any value.
- */
-export type HeadDeduplicationRule = {
-    readonly tag: string;
-    readonly attributes: Readonly<Record<string, string | true>>;
-};
-export type DocumentAttributes = {
-    readonly html: Attributes;
-    readonly head: Attributes;
-    readonly body: Attributes;
-};
-export type HtmlDocumentDeclaration = {
-    readonly _tag: "HtmlDocument";
-    /** Supplies attributes for the initial document's fixed HTML, head, and body elements. */
-    readonly attributesFn: (context: HtmlDocumentContext) => Effect.Effect<DocumentAttributes, unknown, unknown>;
-    /** Supplies managed head defaults independently for initial HTML and navigation. */
-    readonly defaultHeadFn: (context: HtmlDocumentContext) => Effect.Effect<ReadonlyArray<Element>, unknown, unknown>;
-    readonly headDeduplicationRules: ReadonlyArray<HeadDeduplicationRule>;
-};
-export type Declaration = UiLoaderDeclaration | EndpointDeclaration | TaskMiddlewareDeclaration | HtmlDocumentDeclaration;

package/dist/server/graph/literal-error-tag.d.ts

@@ -1,14 +0,0 @@
-import type { Schema } from "effect";
-export type LiteralErrorTag = {
-    readonly field: string;
-    readonly tag: string;
-};
-/**
- * The literal tag a schema discriminates on, when it carries exactly one
- * usable one. A `_tag` field wins when several string literals are present,
- * which is the `Schema.TaggedError` shape; anything else ambiguous, and a
- * schema with no required string literal, has no static tag. Runtime matching
- * validates values against the declared schemas, so this is only the static
- * identity the build checks and the envelope carries.
- */
-export declare function getLiteralErrorTag(schema: Schema.Top): LiteralErrorTag | undefined;

package/dist/server/graph/pattern-conflicts.d.ts

@@ -1,36 +0,0 @@
-type PatternConflictSegment = {
-    readonly kind: "static";
-    readonly value: string;
-} | {
-    readonly kind: "dynamic";
-    readonly parameterName: string;
-} | {
-    readonly kind: "splat";
-} | {
-    readonly kind: "index";
-};
-type DynamicParameterConflict = {
-    readonly attemptedParameterName: string;
-    readonly existingParameterName: string;
-};
-/** Two patterns name the same dynamic branch differently; `pattern` is the one that arrived second. */
-export type ConflictingDynamicParameterNameError = DynamicParameterConflict & {
-    readonly _tag: "ConflictingDynamicParameterName";
-    readonly pattern: string;
-};
-export type DynamicParameterNameConflict<Cause, Pattern> = {
-    readonly patterns: ReadonlyArray<Pattern>;
-    readonly attemptedPattern: Pattern;
-    readonly cause: Cause;
-};
-/** Attributes each shared dynamic-branch name clash to the authored pattern identities that produce it. */
-export declare function findConflictingDynamicParameterNames<Pattern, Cause>(input: {
-    readonly patterns: ReadonlyArray<Pattern>;
-    readonly getMatcherPattern: (pattern: Pattern) => string;
-    readonly getSegments: (pattern: Pattern) => ReadonlyArray<PatternConflictSegment>;
-    readonly makeCause: (input: {
-        readonly conflict: DynamicParameterConflict;
-        readonly attemptedPattern: Pattern;
-    }) => Cause;
-}): ReadonlyArray<DynamicParameterNameConflict<Cause, Pattern>>;
-export {};

package/dist/server/graph/search-schema.d.ts

@@ -1,13 +0,0 @@
-import { Result, type Schema } from "effect";
-import type { SearchContractDocument } from "../../universal/protocol-schemas.ts";
-/** Effect schemas remain at the server boundary; the shared URL parser reads only SearchShape. */
-export type UnsupportedSearchSchemaError = {
-    readonly _tag: "UnsupportedSearchSchema";
-    readonly path: string;
-    readonly reason: string;
-};
-export type DerivedSearchContract = {
-    readonly document: SearchContractDocument;
-    readonly fields: ReadonlySet<string>;
-};
-export declare function deriveSearchContract(schema: Schema.Top): Result.Result<DerivedSearchContract, UnsupportedSearchSchemaError>;

package/dist/server/graph/transport-schema.d.ts

@@ -1,11 +0,0 @@
-import { Result, type Schema } from "effect";
-export type TransportSchemaIssue = {
-    readonly _tag: "UntransportableSchema";
-    readonly path: string;
-    readonly reason: string;
-};
-export declare function checkTransportSchema(input: {
-    readonly schema: Schema.Top;
-    /** An error contract's root may be a class; its instance travels as its fields. */
-    readonly allowClassRoot: boolean;
-}): Result.Result<void, TransportSchemaIssue>;

package/dist/server/index.d.ts

@@ -1,310 +0,0 @@
-import { TaskContext, TaskRuntime } from "@vorma/primitives/tasks";
-import { Effect, Layer, type Stream } from "effect";
-import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
-import type { MissingGeneratedApplicationKey, MissingGeneratedApplicationTypes } from "../universal/generated-types.ts";
-import type { VormaConfig } from "./config/index.ts";
-import type { Element } from "./document.ts";
-import type { FormInputServices } from "./form-data.ts";
-import type { DocumentAttributes, HeadDeduplicationRule, DeclaredSchema, EndpointErrorDeclaration, EndpointKind, HtmlDocumentContext as UntypedHtmlDocumentContext, HtmlDocumentDeclaration, HttpMethod, ResponseEndpointDeclaration, StreamEndpointDeclaration, TaskMiddlewareDeclaration, UiLoaderDeclaration } from "./graph/declarations.ts";
-import { makePublicAssetsFileMiddleware } from "./public-assets.ts";
-import { APPLICATION_RUNTIME, type CompiledApplication } from "./runtime/application.ts";
-import type { HeadOps, MiddlewareRequestFacts, RequestFacts, ResponseInputError, ResponseOps } from "./runtime/context.ts";
-import type { RedirectStatus } from "./runtime/effects.ts";
-import { type VormaStartupError } from "./runtime/startup-error.ts";
-export { HandlerError } from "./runtime/handler.ts";
-export { ResponseInputError } from "./runtime/context.ts";
-export type { RedirectStatus } from "./runtime/effects.ts";
-export type { EndpointKind } from "./graph/declarations.ts";
-export type { ProductionMetadata } from "../universal/protocol.ts";
-export type { VormaStartupError } from "./runtime/startup-error.ts";
-export type { Attributes as HtmlAttributes, Element as HeadElement, } from "./document.ts";
-export { escapeJsonForScript } from "./document.ts";
-export type { DocumentAttributes, HeadDeduplicationRule, } from "./graph/declarations.ts";
-export type ParamsOf<Pattern extends string> = Pattern extends `${string}:${infer Name}/${infer Rest}` ? {
-    readonly [K in Name | keyof ParamsOf<`/${Rest}`>]: string;
-} : Pattern extends `${string}:${infer Name}` ? {
-    readonly [K in Name]: string;
-} : {};
-/** Filled in by the generated declaration: the application's patterns, route searches, and asset keys. */
-export interface Register {
-}
-type RegisteredPattern = Register extends {
-    readonly patterns: infer V extends string;
-} ? V : MissingGeneratedApplicationKey;
-type RegisteredAssetKey = Register extends {
-    readonly assets: infer A extends string;
-} ? A | `/${A}` : MissingGeneratedApplicationKey;
-type RegisteredRouteSearch = Register extends {
-    readonly routeSearch: infer Search;
-} ? Search : Readonly<Record<string, unknown>>;
-type ParamsField<P extends string> = keyof ParamsOf<P> extends never ? {
-    readonly params?: never;
-} : {
-    readonly params: ParamsOf<P>;
-};
-type SplatField<P extends string> = P extends `${string}/*` ? {
-    readonly splatValues: ReadonlyArray<string>;
-} : {
-    readonly splatValues?: never;
-};
-type RequiredKeys<Value> = Value extends object ? {
-    [Key in keyof Value]-?: {} extends Pick<Value, Key> ? never : Key;
-}[keyof Value] : never;
-type RouteInputField<P extends RegisteredPattern> = P extends keyof RegisteredRouteSearch ? [RegisteredRouteSearch[P]] extends [undefined] ? {
-    readonly input?: never;
-} : RequiredKeys<RegisteredRouteSearch[P]> extends never ? {
-    readonly input?: RegisteredRouteSearch[P];
-} : {
-    readonly input: RegisteredRouteSearch[P];
-} : {
-    readonly input?: unknown;
-};
-type DestinationPattern<P extends string> = P extends `${infer Prefix}/_index` ? P | (Prefix extends "" ? "/" : Prefix) : P;
-/** A redirect target with generated parameters and decoded route input. */
-export type PatternTarget = {
-    readonly [P in RegisteredPattern]: {
-        readonly pattern: DestinationPattern<P>;
-        readonly hash?: string;
-    } & ParamsField<P> & SplatField<P> & RouteInputField<P>;
-}[RegisteredPattern];
-type TypedFacts<Pattern extends string, Params, Input> = Omit<RequestFacts<Pattern, Params, Input>, "getPublicUrl"> & {
-    /** The hashed URL of a public asset, typed by the generated asset keys. Leading slash optional. */
-    readonly getPublicUrl: (key: RegisteredAssetKey) => string;
-};
-type TypedResponseOps = Omit<ResponseOps, "redirectToPattern"> & {
-    readonly redirectToPattern: (options: PatternTarget & {
-        readonly status: RedirectStatus;
-    }) => Effect.Effect<never, ResponseInputError>;
-};
-type TypedMiddlewareFacts = Omit<MiddlewareRequestFacts, "getPublicUrl"> & {
-    /** The hashed URL of a public asset, typed by the generated asset keys. Leading slash optional. */
-    readonly getPublicUrl: (key: RegisteredAssetKey) => string;
-};
-export type LoaderContext<Pattern extends string, Params, Input> = TypedFacts<Pattern, Params, Input> & TypedResponseOps & HeadOps;
-export type EndpointContext<Pattern extends string, Params, Input> = TypedFacts<Pattern, Params, Input> & TypedResponseOps;
-export type StreamContext<Pattern extends string, Params, Input> = TypedFacts<Pattern, Params, Input> & {
-    /** The event number a reconnecting client resumed from. */
-    readonly resumeCursor: number | undefined;
-};
-export type MiddlewareContext = TypedMiddlewareFacts & TypedResponseOps & HeadOps;
-declare const DEFINITION_TYPES: unique symbol;
-type HandlerTypes<Input, Output, Failure, Requirements> = {
-    readonly input: Input;
-    readonly output: Output;
-    readonly failure: Failure;
-    readonly requirements: Requirements;
-};
-/**
- * A query's or mutation's handler types, its declared errors, each with its
- * schema's decoded type, and the encoded side of its input, which identifies
- * Effect's native multipart record for form transport.
- */
-type EndpointHandlerTypes<Input, InputEncoded, Output, Failure, Requirements, Errors> = HandlerTypes<Input, Output, Failure, Requirements> & {
-    readonly inputEncoded: InputEncoded;
-    readonly errors: Errors;
-};
-type ServiceTypes<Failure, Requirements> = {
-    readonly failure: Failure;
-    readonly requirements: Requirements;
-};
-type WithDefinitionTypes<Types> = {
-    readonly [DEFINITION_TYPES]?: Types;
-};
-/** The static types a definition carries. */
-type DefinitionTypesOf<Definition extends WithDefinitionTypes<unknown>> = NonNullable<Definition[typeof DEFINITION_TYPES]>;
-export type UiLoaderDefinition<Pattern extends string = string, Input = unknown, Output = unknown, Failure = never, Requirements = never> = UiLoaderDeclaration & {
-    readonly pattern: Pattern;
-} & WithDefinitionTypes<HandlerTypes<Input, Output, Failure, Requirements>>;
-export type ResponseEndpointDefinition<Kind extends "query" | "mutation" = "query" | "mutation", Pattern extends string = string, Input = unknown, Output = unknown, Failure = never, Requirements = never, Errors extends ReadonlyArray<EndpointErrorDeclaration> = ReadonlyArray<EndpointErrorDeclaration>, Method extends HttpMethod = HttpMethod, InputEncoded = unknown> = ResponseEndpointDeclaration & {
-    readonly kind: Kind;
-    readonly method: Method;
-    readonly pattern: Pattern;
-} & WithDefinitionTypes<EndpointHandlerTypes<Input, InputEncoded, Output, Failure, Requirements, Errors>>;
-export type StreamEndpointDefinition<Pattern extends string = string, Input = unknown, Event = unknown, Failure = never, Requirements = never> = StreamEndpointDeclaration & {
-    readonly method: "GET";
-    readonly pattern: Pattern;
-} & WithDefinitionTypes<HandlerTypes<Input, Event, Failure, Requirements>>;
-export type MiddlewareDefinition<Failure = never, Requirements = never> = TaskMiddlewareDeclaration & WithDefinitionTypes<ServiceTypes<Failure, Requirements>>;
-export type HtmlDocumentDefinition<Failure = never, Requirements = never> = HtmlDocumentDeclaration & WithDefinitionTypes<ServiceTypes<Failure, Requirements>>;
-type LoaderFn<Pattern extends string, Input, Output, Failure, Requirements> = (context: LoaderContext<Pattern, ParamsOf<Pattern>, Input>) => Effect.Effect<Output, Failure, Requirements>;
-declare function makeUiLoader<const Pattern extends string, InputSchema extends DeclaredSchema, OutputSchema extends DeclaredSchema, Failure, Requirements>(definition: {
-    readonly pattern: Pattern;
-    readonly input: InputSchema;
-    readonly output: OutputSchema;
-    readonly fn: LoaderFn<Pattern, InputSchema["Type"], OutputSchema["Type"], Failure, Requirements>;
-}): UiLoaderDefinition<Pattern, InputSchema["Type"], OutputSchema["Type"], Failure, Requirements>;
-declare function makeUiLoader<const Pattern extends string, OutputSchema extends DeclaredSchema, Failure, Requirements>(definition: {
-    readonly pattern: Pattern;
-    readonly output: OutputSchema;
-    readonly fn: LoaderFn<Pattern, undefined, OutputSchema["Type"], Failure, Requirements>;
-}): UiLoaderDefinition<Pattern, undefined, OutputSchema["Type"], Failure, Requirements>;
-export declare const UiLoader: {
-    readonly make: typeof makeUiLoader;
-};
-export { FormData } from "./form-data.ts";
-type EndpointFn<Pattern extends string, Input, Output, Failure, Requirements> = (context: EndpointContext<Pattern, ParamsOf<Pattern>, Input>) => Effect.Effect<Output, Failure, Requirements>;
-type StreamFn<Pattern extends string, Input, Event, Failure, Requirements> = (context: StreamContext<Pattern, ParamsOf<Pattern>, Input>) => Stream.Stream<Event, Failure, Requirements>;
-/** A stream whose input schema decodes the search parameters. */
-declare function makeStreamEndpoint<const Pattern extends string, InputSchema extends DeclaredSchema, EventSchema extends DeclaredSchema, Failure, Requirements>(definition: {
-    readonly method: "GET";
-    readonly pattern: Pattern;
-    readonly input: InputSchema;
-    readonly event: EventSchema;
-    readonly fn: StreamFn<Pattern, InputSchema["Type"], EventSchema["Type"], Failure, Requirements>;
-}): StreamEndpointDefinition<Pattern, InputSchema["Type"], EventSchema["Type"], Failure, Requirements>;
-/** A stream without input. */
-declare function makeStreamEndpoint<const Pattern extends string, EventSchema extends DeclaredSchema, Failure, Requirements>(definition: {
-    readonly method: "GET";
-    readonly pattern: Pattern;
-    readonly event: EventSchema;
-    readonly fn: StreamFn<Pattern, undefined, EventSchema["Type"], Failure, Requirements>;
-}): StreamEndpointDefinition<Pattern, undefined, EventSchema["Type"], Failure, Requirements>;
-export declare const QueryEndpoint: {
-    readonly make: {
-        <const Pattern extends string, const Method extends HttpMethod, InputSchema extends DeclaredSchema, OutputSchema extends DeclaredSchema, Failure, Requirements, const Errors extends ReadonlyArray<EndpointErrorDeclaration> = readonly []>(definition: {
-            readonly method: Method;
-            readonly pattern: Pattern;
-            readonly input: InputSchema;
-            readonly output: OutputSchema;
-            /** Expected application failures: each entry's schema and explicit HTTP error status. */
-            readonly errors?: Errors;
-            readonly fn: EndpointFn<Pattern, InputSchema["Type"], OutputSchema["Type"], Failure, Requirements>;
-        }): ResponseEndpointDefinition<"query", Pattern, InputSchema["Type"], OutputSchema["Type"], Failure, Requirements | (Method extends "GET" ? never : FormInputServices<InputSchema>), Errors, Method, InputSchema["Encoded"]>;
-        <const Pattern extends string, const Method extends HttpMethod, OutputSchema extends DeclaredSchema, Failure, Requirements, const Errors extends ReadonlyArray<EndpointErrorDeclaration> = readonly []>(definition: {
-            readonly method: Method;
-            readonly pattern: Pattern;
-            readonly output: OutputSchema;
-            /** Expected application failures: each entry's schema and explicit HTTP error status. */
-            readonly errors?: Errors;
-            readonly fn: EndpointFn<Pattern, undefined, OutputSchema["Type"], Failure, Requirements>;
-        }): ResponseEndpointDefinition<"query", Pattern, undefined, OutputSchema["Type"], Failure, Requirements, Errors, Method, undefined>;
-    };
-};
-export declare const MutationEndpoint: {
-    readonly make: {
-        <const Pattern extends string, const Method extends HttpMethod, InputSchema extends DeclaredSchema, OutputSchema extends DeclaredSchema, Failure, Requirements, const Errors extends ReadonlyArray<EndpointErrorDeclaration> = readonly []>(definition: {
-            readonly method: Method;
-            readonly pattern: Pattern;
-            readonly input: InputSchema;
-            readonly output: OutputSchema;
-            /** Expected application failures: each entry's schema and explicit HTTP error status. */
-            readonly errors?: Errors;
-            readonly fn: EndpointFn<Pattern, InputSchema["Type"], OutputSchema["Type"], Failure, Requirements>;
-        }): ResponseEndpointDefinition<"mutation", Pattern, InputSchema["Type"], OutputSchema["Type"], Failure, Requirements | (Method extends "GET" ? never : FormInputServices<InputSchema>), Errors, Method, InputSchema["Encoded"]>;
-        <const Pattern extends string, const Method extends HttpMethod, OutputSchema extends DeclaredSchema, Failure, Requirements, const Errors extends ReadonlyArray<EndpointErrorDeclaration> = readonly []>(definition: {
-            readonly method: Method;
-            readonly pattern: Pattern;
-            readonly output: OutputSchema;
-            /** Expected application failures: each entry's schema and explicit HTTP error status. */
-            readonly errors?: Errors;
-            readonly fn: EndpointFn<Pattern, undefined, OutputSchema["Type"], Failure, Requirements>;
-        }): ResponseEndpointDefinition<"mutation", Pattern, undefined, OutputSchema["Type"], Failure, Requirements, Errors, Method, undefined>;
-    };
-};
-/** Unimplemented declaration scaffold. The build rejects registered stream endpoints. */
-export declare const StreamEndpoint: {
-    readonly make: typeof makeStreamEndpoint;
-};
-declare function makeTaskMiddleware<Failure, Requirements>(definition: {
-    /** Which requests it selects. Written, never inferred: `"/*"` means every path. */
-    readonly patterns: ReadonlyArray<string>;
-    readonly methods: ReadonlyArray<HttpMethod>;
-    readonly fn: (context: MiddlewareContext) => Effect.Effect<void, Failure, Requirements>;
-}): MiddlewareDefinition<Failure, Requirements>;
-export declare const TaskMiddleware: {
-    readonly make: typeof makeTaskMiddleware;
-};
-export type HtmlDocumentContext = Omit<UntypedHtmlDocumentContext, "getPublicUrl"> & {
-    readonly getPublicUrl: (key: RegisteredAssetKey) => string;
-};
-declare function makeHtmlDocument<AttributesFailure, AttributesRequirements, HeadFailure, HeadRequirements>(definition: {
-    readonly attributesFn: (context: HtmlDocumentContext) => Effect.Effect<DocumentAttributes, AttributesFailure, AttributesRequirements>;
-    readonly defaultHeadFn: (context: HtmlDocumentContext) => Effect.Effect<ReadonlyArray<Element>, HeadFailure, HeadRequirements>;
-    readonly headDeduplicationRules?: ReadonlyArray<HeadDeduplicationRule>;
-}): HtmlDocumentDefinition<AttributesFailure | HeadFailure, AttributesRequirements | HeadRequirements>;
-export declare const HtmlDocument: {
-    readonly make: typeof makeHtmlDocument;
-};
-type AnyLoader = UiLoaderDefinition<any, any, any, any, any>;
-type AnyEndpoint = ResponseEndpointDefinition<any, any, any, any, any, any, any, any, any> | StreamEndpointDefinition<any, any, any, any, any>;
-type AnyMiddleware = MiddlewareDefinition<any, any>;
-type AnyHtmlDocument = HtmlDocumentDefinition<any, any>;
-declare const APPLICATION_TYPES: unique symbol;
-type RegisteredDeclarations = Register extends {
-    readonly declarations: infer Declarations extends ReadonlyArray<RegisterableDeclaration>;
-} ? Declarations : readonly [];
-type GeneratedApplicationCheck = Register extends {
-    readonly declarations: ReadonlyArray<RegisterableDeclaration>;
-} ? unknown : MissingGeneratedApplicationTypes;
-export type Application<Loaders extends AnyLoader = AnyLoader, Endpoints extends AnyEndpoint = AnyEndpoint, Middleware extends AnyMiddleware = AnyMiddleware, HtmlDocument extends AnyHtmlDocument = AnyHtmlDocument> = {
-    readonly _tag: "Application";
-    readonly [APPLICATION_RUNTIME]: Layer.Layer<CompiledApplication, VormaStartupError>;
-    readonly [APPLICATION_TYPES]?: {
-        readonly loaders: Loaders;
-        readonly endpoints: Endpoints;
-    };
-    readonly document: HtmlDocument;
-    readonly middleware: ReadonlyArray<Middleware>;
-};
-export type UiLoadersOf<A> = A extends Application<infer L, any, any, any> ? L : never;
-type EndpointsOf<A, Kind extends EndpointKind> = A extends Application<any, infer E, any, any> ? Extract<E, {
-    readonly kind: Kind;
-}> : never;
-/** Per kind: the union of services the handlers of that kind yield. */
-export type LoaderRequirementsOf<A> = DefinitionTypesOf<UiLoadersOf<A>>["requirements"];
-export type QueryRequirementsOf<A> = DefinitionTypesOf<EndpointsOf<A, "query">>["requirements"];
-export type MutationRequirementsOf<A> = DefinitionTypesOf<EndpointsOf<A, "mutation">>["requirements"];
-export type StreamRequirementsOf<A> = DefinitionTypesOf<EndpointsOf<A, "stream">>["requirements"];
-export type MiddlewareRequirementsOf<A> = A extends Application<any, any, infer M, any> ? DefinitionTypesOf<M>["requirements"] : never;
-export type HtmlDocumentRequirementsOf<A> = A extends Application<any, any, any, infer D> ? DefinitionTypesOf<D>["requirements"] : never;
-/**
- * One service-layer property, required exactly when the declarations of that
- * kind require a service; otherwise optional, and omission supplies nothing.
- */
-type ServiceLayer<Name extends string, Requirements, E, LayerRequirements, RequestServices> = [
-    Exclude<Requirements, TaskContext | TaskRuntime | HttpRouter.Provided | RequestServices>
-] extends [never] ? {
-    readonly [K in Name]?: Layer.Layer<never, E, LayerRequirements>;
-} : {
-    readonly [K in Name]: Layer.Layer<Exclude<Requirements, TaskContext | TaskRuntime | HttpRouter.Provided | RequestServices>, E, LayerRequirements>;
-};
-/** The services the document and each handler kind may use, as one layer per recipient. */
-export type ServiceLayers<A, E, LayerRequirements, RequestServices = never> = ServiceLayer<"documentServices", HtmlDocumentRequirementsOf<A>, E, LayerRequirements, RequestServices> & ServiceLayer<"uiLoaderServices", LoaderRequirementsOf<A>, E, LayerRequirements, RequestServices> & ServiceLayer<"queryServices", QueryRequirementsOf<A>, E, LayerRequirements, RequestServices> & ServiceLayer<"mutationServices", MutationRequirementsOf<A>, E, LayerRequirements, RequestServices> & ServiceLayer<"streamServices", StreamRequirementsOf<A>, E, LayerRequirements, RequestServices> & ServiceLayer<"middlewareServices", MiddlewareRequirementsOf<A>, E, LayerRequirements, RequestServices>;
-/** A declaration the build registers automatically: every export of the server project with one of these types. */
-export type RegisterableDeclaration = AnyLoader | AnyEndpoint;
-/**
- * Connects configuration, the document, and ordered task middleware without
- * starting execution. Explicit startup acquires the compiled declarations and
- * metadata through one shared application Layer.
- */
-declare function makeApplication<const Middleware extends ReadonlyArray<AnyMiddleware>, HtmlDocument extends AnyHtmlDocument>(input: {
-    readonly config: VormaConfig;
-    readonly document: HtmlDocument;
-    /** In execution order: a later middleware's non-terminal contributions replace an earlier one's, and the first terminal outcome wins. */
-    readonly middleware: Middleware;
-} & GeneratedApplicationCheck): Application<Extract<RegisteredDeclarations[number], AnyLoader>, Extract<RegisteredDeclarations[number], AnyEndpoint>, Middleware[number], HtmlDocument>;
-/**
- * Acquires handlers for application-controlled mounting. Per-kind Layers provide
- * application services, and the optional request Layer supplies request services.
- */
-declare function makeHandlers<App extends Application<any, any, any, any>, E = never, LayerRequirements = never, RequestServices = never, RequestError = never, RequestRequirements = never>(options: {
-    readonly app: App;
-    /** Acquired once per request, within its task context and scope. Omission adds no request services. */
-    readonly requestServices?: Layer.Layer<RequestServices, RequestError, RequestRequirements | HttpServerRequest.HttpServerRequest | TaskContext | TaskRuntime>;
-} & ServiceLayers<App, E, LayerRequirements, NoInfer<RequestServices>>): Effect.Effect<{
-    ui: Effect.Effect<HttpServerResponse.HttpServerResponse, RequestError | import("./development/metadata.ts").DevelopmentMetadataIssue | VormaStartupError | (import("effect/unstable/http/HttpServerError").HttpServerError | import("effect/unstable/http/Multipart").MultipartError), HttpServerRequest.HttpServerRequest | Exclude<Exclude<RequestRequirements, TaskContext>, TaskRuntime> | (import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("effect/Scope").Scope)>;
-    /** Base64 SHA-256 of the exact inline critical CSS; use it in a CSP hash source. */
-    getCriticalCssContentSha256: () => Effect.Effect<string, import("./development/metadata.ts").DevelopmentMetadataIssue, never>;
-    forEndpointMethod: (method: HttpMethod) => Effect.Effect<HttpServerResponse.HttpServerResponse, RequestError | import("./development/metadata.ts").DevelopmentMetadataIssue | VormaStartupError | (import("effect/unstable/http/HttpServerError").HttpServerError | import("effect/unstable/http/Multipart").MultipartError), HttpServerRequest.HttpServerRequest | Exclude<Exclude<RequestRequirements, TaskContext>, TaskRuntime> | (import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("effect/Scope").Scope)>;
-}, E | VormaStartupError, import("effect/Scope").Scope | Exclude<LayerRequirements, CompiledApplication>>;
-export declare const Vorma: {
-    /** Inert application construction from configuration, a document, and ordered task middleware. */
-    readonly makeApplication: typeof makeApplication;
-    /**
-     * Acquires UI and endpoint handlers. The application selects each native
-     * registration's method and path and owns serving and service composition.
-     */
-    readonly makeHandlers: typeof makeHandlers;
-    /** Creates file-serving middleware that the application explicitly mounts. */
-    readonly makePublicAssetsFileMiddleware: typeof makePublicAssetsFileMiddleware;
-};