@sjcx/vorma 0.0.0-pre.6 → 0.0.0-pre.8

package/dist/build/dev/index-html.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The markup that Vite produced, with every root-relative URL in an `src` or
+ * `href` attribute and in an import specifier of an inline script resolved
+ * against the module server's origin. Absolute and protocol-relative URLs stay
+ * as they are.
+ */
+export declare function toModuleServerHtml(input: {
+    readonly html: string;
+    /** `http://127.0.0.1:<port>`. */
+    readonly moduleServerOrigin: string;
+}): string;
+/** What Vite's plugins add to a document, by the place where each part goes. */
+export type IndexHtmlParts = {
+    /** The tags with `injectTo` set to `"head-prepend"`, `"head"`, or nothing, in Vite's order. */
+    readonly headHtml: string;
+    /** The tags with `injectTo` set to `"body-prepend"`. */
+    readonly bodyPrependHtml: string;
+    /** The tags with `injectTo` set to `"body"`. */
+    readonly bodyHtml: string;
+};
+/**
+ * The page that `splitIndexHtml` expects Vite to transform. The comment in
+ * the body separates the tags that Vite puts at the start of the body from the
+ * tags that it puts at the end.
+ */
+export declare const INDEX_HTML_TEMPLATE = "<head></head><body><!--vorma-body-separator--></body>";
+/** Splits Vite's transformation of `INDEX_HTML_TEMPLATE` into what goes in each place of the document. */
+export declare function splitIndexHtml(html: string): IndexHtmlParts;

package/dist/build/dev/module-server.d.ts

@@ -0,0 +1,24 @@
+import { type RequestListener } from "node:http";
+import { Effect } from "effect";
+export type DevModuleServerIssue = {
+    readonly _tag: "DevModuleServerIssue";
+    readonly cause: unknown;
+};
+/** Where Vorma's module server listens; development documents load browser modules from its origin. */
+export type DevModuleServerAddress = {
+    readonly port: number;
+    /** `http://127.0.0.1:<port>`. */
+    readonly origin: string;
+    /** `ws://127.0.0.1:<port>`, which Vite's hot update connection uses. */
+    readonly webSocketOrigin: string;
+};
+export declare function createDevModuleServerAddress(port: number): DevModuleServerAddress;
+/** Hosts only Vite middleware and its WebSocket; the application has its own server. */
+export declare function createDevModuleServer(address: DevModuleServerAddress): Effect.Effect<{
+    server: import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse>;
+    listen: Effect.Effect<void, DevModuleServerIssue, never>;
+    origin: string;
+    webSocketOrigin: string;
+    port: number;
+    setHandler(next: RequestListener): void;
+}, never, import("effect/Scope").Scope>;

package/dist/build/dev/patterns.d.ts

@@ -0,0 +1,26 @@
+import type { DevAction, VormaConfig } from "../../config.ts";
+export type DevChangeRules = ReturnType<typeof compileDevChangeRules>;
+type DevOnChangeRule = NonNullable<NonNullable<VormaConfig["dev"]>["onChange"]>[number];
+/**
+ * The messages for the `dev.onChange` rules that cannot work: a pattern that is
+ * empty once trimmed, including `"!"`, and a rule whose patterns are all
+ * exclusions, which match nothing.
+ */
+export declare function findInvalidDevChangeRules(rules: ReadonlyArray<DevOnChangeRule>): ReadonlyArray<string>;
+/** Ordered inclusion and exclusion rules use native Vite glob matching. */
+export declare function compileDevPatterns(patterns: ReadonlyArray<string>): {
+    roots: string[];
+    testRelativePathMatched(relativePath: string): boolean;
+};
+/**
+ * Compiles the `dev.onChange` rules. A rule applies to a changed file that one
+ * of its patterns matches; the patterns are relative to the configuration
+ * directory.
+ */
+export declare function compileDevChangeRules(rules: ReadonlyArray<DevOnChangeRule>): {
+    /** The directories that the patterns can match below. */
+    roots: string[];
+    /** The actions of the rules with a pattern that matches a changed file. */
+    getFileActions(relativePath: string): ReadonlyArray<DevAction>;
+};
+export {};

package/dist/build/dev/ports.d.ts

@@ -0,0 +1,25 @@
+import { Effect } from "effect";
+/** Where `vorma dev` starts looking for the application server's port when the configuration sets no `dev.server.preferredPort`. */
+export declare const APPLICATION_PREFERRED_PORT = 8080;
+/** Where `vorma dev` starts looking for its module server's port: Vite's own default. */
+export declare const MODULE_SERVER_PREFERRED_PORT = 5173;
+/**
+ * Reserves the preferred port when it is free, otherwise the first free port
+ * among the 1,024 ports after it, otherwise a port that the operating system
+ * assigns. The reservation listens on every address until the enclosing scope
+ * closes, so a concurrent `vorma dev` process chooses a different port. Close
+ * the scope just before the port's owner starts listening.
+ */
+export declare function reserveFirstFreePort(input: {
+    readonly preferredPort: number;
+}): Effect.Effect<number, import("effect/socket/SocketServer").SocketServerError, import("effect/Scope").Scope>;
+/**
+ * Reserves exactly this port, or fails when it is not free. A port is free
+ * when it can be bound on the loopback address and then on every address. The
+ * loopback check is released at once; the binding on every address remains as
+ * the reservation until the enclosing scope closes.
+ */
+export declare function reserveExactPort(port: number): Effect.Effect<{
+    readonly address: import("effect/net/NetAddress").SocketAddress;
+    readonly run: <R, E, _>(handler: (socket: import("effect/socket/Socket").Socket) => Effect.Effect<_, E, R>) => Effect.Effect<never, import("effect/socket/SocketServer").SocketServerError, R>;
+}, import("effect/socket/SocketServer").SocketServerError, import("effect/Scope").Scope>;

package/dist/build/dev/server-process.d.ts

@@ -0,0 +1,34 @@
+import { type Duration, Effect } from "effect";
+export type DevServerExitIssue = {
+    readonly _tag: "DevServerExitIssue";
+    readonly exitCode: number;
+};
+/**
+ * Runs the configured server command; its Effect scope owns process
+ * termination. The process is ready when Vorma's handler answers the
+ * readiness path at `http://localhost:<port>` with 200 and the build ID that
+ * `vorma dev` published for it. Vorma waits until the process is ready or
+ * exits; after `waitingMsgDelay`, it prints the URL that it is waiting on
+ * and keeps waiting.
+ */
+export declare function startDevServerProcess(input: {
+    readonly cmd: readonly [string, ...Array<string>];
+    readonly configDir: string;
+    readonly port: number;
+    /** The dist directory, in which the server reads the build directory of `vorma dev`. */
+    readonly distDir: string;
+    readonly expectedClientBuildId: string;
+    readonly waitingMsgDelay: Duration.Input;
+}): Effect.Effect<{
+    childProcess: import("effect/process/ChildProcessSpawner").ChildProcessHandle;
+    unexpectedExit: Effect.Effect<never, import("effect/PlatformError").PlatformError | {
+        _tag: "DevServerExitIssue";
+        exitCode: number & import("effect/Brand").Brand<"ExitCode">;
+    }, never>;
+}, import("effect/PlatformError").PlatformError | {
+    readonly _tag: "NotReady";
+    readonly description: string;
+} | {
+    _tag: "DevServerExitIssue";
+    exitCode: number & import("effect/Brand").Brand<"ExitCode">;
+}, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/Scope").Scope>;

package/dist/build/dev/server-sources.d.ts

@@ -0,0 +1,19 @@
+import { Effect, FileSystem, Path } from "effect";
+import type { CargoMetadata } from "./cargo-metadata.ts";
+/**
+ * The files whose changes rebuild the Rust server: every file that compiling
+ * the binary read outside Cargo's registry, which Cargo lists in the
+ * dependency file beside the executable, plus the files that decide what Cargo
+ * compiles, which the dependency file omits: the server's manifest and the
+ * workspace's root manifest and lockfile.
+ */
+export declare function readServerSourceFiles(input: {
+    readonly executable: string;
+    readonly cargoManifestFilePath: string;
+    readonly cargo: CargoMetadata;
+}): Effect.Effect<Set<string>, {
+    _tag: "InspectionIssues";
+    issues: {
+        msg: string;
+    }[];
+}, FileSystem.FileSystem | Path.Path>;

package/dist/build/dev/session.d.ts

@@ -0,0 +1,28 @@
+import { Effect, FileSystem, Path, Result } from "effect";
+import type { ResolvedDev, ResolvedVormaConfig } from "../config/resolve-config.ts";
+/**
+ * Runs until interrupted; configuration replacement releases the complete
+ * previous session. The application keeps one port for the whole run, chosen
+ * from `dev.server.preferredPort` in the first configuration. Each session
+ * reserves its module server's port, starting the search at the previous
+ * session's port, or at 5173 for the first session.
+ */
+export declare function developApplication(configPath: string): Effect.Effect<never, unknown, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | FileSystem.FileSystem | Path.Path>;
+/**
+ * Cargo's metadata for the configured manifest, as a result, and the paths
+ * that the watcher ignores. Every Cargo build writes the target directory,
+ * which is often inside a watched directory, so the watcher learns it before
+ * it first scans; while Cargo cannot report it, nothing runs Cargo.
+ */
+export declare function readConfiguredCargoMetadata(resolved: ResolvedVormaConfig & {
+    readonly dev: ResolvedDev;
+}): Effect.Effect<{
+    cargo: Result.Result<{
+        targetDir: string;
+        workspaceRoot: string;
+    }, {
+        _tag: "CargoMetadataIssue";
+        msg: string;
+    }>;
+    generatedPaths: readonly string[];
+}, never, import("effect/process/ChildProcessSpawner").ChildProcessSpawner>;

package/dist/build/dev/sources.d.ts

@@ -0,0 +1,46 @@
+import { Effect, Path } from "effect";
+import { type CompiledRustServer } from "../inspection/rust-server.ts";
+import type { DevLayout } from "./generated-paths.ts";
+export type DevSourceInputs = {
+    /** The Rust server's inspection, which an inspection after a client-only change reuses. */
+    readonly server: CompiledRustServer;
+    /** The files whose changes rebuild the Rust server. */
+    readonly serverFiles: ReadonlySet<string>;
+    readonly clientFiles: ReadonlySet<string>;
+    readonly clientRootFiles: ReadonlySet<string>;
+    /** Configuration and resolution inputs of the client project that are not program source files. */
+    readonly resolutionFiles: ReadonlySet<string>;
+    /** Native compiler directory enumeration, including configured inclusion scopes. */
+    readonly dirs: ReadonlySet<string>;
+};
+/**
+ * Inspects declarations and records the server's and the client compiler's
+ * inputs without replacing filesystem behavior. `server` reuses the previous
+ * inputs' server inspection when no server source changed, so the inspection
+ * runs neither Cargo nor the server.
+ */
+export declare function inspectDevSources(input: {
+    readonly layout: DevLayout;
+    readonly server: {
+        readonly _tag: "Inspect";
+    } | {
+        readonly _tag: "Reuse";
+        readonly previous: DevSourceInputs;
+    };
+}): Effect.Effect<{
+    inspection: import("../inspection/inspect-projects.ts").InspectedProjects;
+    inputs: DevSourceInputs;
+}, import("../inspection/typescript-projects.ts").TsProjectIssue | {
+    _tag: "InspectionIssues";
+    issues: import("../inspection/inspect-projects.ts").InspectionIssue[];
+} | {
+    _tag: "InspectionIssues";
+    issues: {
+        msg: string;
+    }[];
+}, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/FileSystem").FileSystem | Path.Path>;
+/** Watches native compiler inputs while keeping generated writes out of the event stream. */
+export declare function getDevSourceWatchPaths(input: {
+    readonly layout: DevLayout;
+    readonly sources: DevSourceInputs;
+}): Effect.Effect<string[], never, Path.Path>;

package/dist/build/{development-stylesheet.d.ts → dev/stylesheet.d.ts}

@@ -1,15 +1,15 @@
 import { Effect } from "effect";
 import { type ViteDevServer } from "vite";
-export type DevelopmentStylesheetIssue = {
-    readonly _tag: "DevelopmentStylesheetIssue";
+export type DevStylesheetIssue = {
+    readonly _tag: "DevStylesheetIssue";
     readonly filePath: string;
     readonly cause: unknown;
 };
 /** Reads CSS and its dependency files from Vite's native direct-CSS pipeline. */
-export declare function readDevelopmentStylesheet(input: {
+export declare function readDevStylesheet(input: {
     readonly server: ViteDevServer;
     readonly filePath: string;
 }): Effect.Effect<{
     css: string;
     inputFilePaths: string[];
-}, DevelopmentStylesheetIssue, never>;
+}, DevStylesheetIssue, never>;

package/dist/build/dev/watcher.d.ts

@@ -0,0 +1,30 @@
+import { Effect } from "effect";
+/** The native watcher could not start. */
+export type DevWatchIssue = {
+    readonly _tag: "DevWatchIssue";
+    readonly cause: unknown;
+};
+/**
+ * Whether a path is inside a directory named `node_modules`, `target`, or
+ * `.git` at any level below the configuration directory. Vorma's watcher and
+ * Vite's watcher both ignore these paths. Directories above the configuration
+ * directory do not count, so a project inside a directory with one of these
+ * names is still watched.
+ */
+export declare function testIgnoredDirPath(input: {
+    readonly configDir: string;
+    readonly filePath: string;
+}): boolean;
+/** Application watching survives Vite restarts and failed replacement builds. */
+export declare function createDevWatcher(input: {
+    readonly configFilePath: string;
+    readonly generatedPaths: ReadonlyArray<string>;
+}): Effect.Effect<{
+    take: Effect.Effect<ReadonlySet<string>, never, never>;
+    recordChange: (filePath: string) => void;
+    recordError: (cause: unknown) => void;
+    watchPaths(next: {
+        readonly paths: ReadonlyArray<string>;
+        readonly generatedPaths: ReadonlyArray<string>;
+    }): Effect.Effect<void, DevWatchIssue, never>;
+}, DevWatchIssue, import("effect/Scope").Scope>;

package/dist/build/dev/work.d.ts

@@ -0,0 +1,67 @@
+import { Effect, Path } from "effect";
+import type { DevLayout } from "./generated-paths.ts";
+import type { DevChangeRules } from "./patterns.ts";
+import type { DevSourceInputs } from "./sources.ts";
+/**
+ * The updates that watcher batches ask for, one field per kind of update. An
+ * update of one kind replaces the earlier requests of its kind. A server
+ * update also does the work of the client and static updates.
+ */
+export type DevWork = {
+    /**
+     * A Rust source of the server, a Cargo manifest, the Cargo lockfile, or a
+     * file that a `"restart-server"` rule names changed. The update builds and
+     * inspects the server, stops it while it does, and starts it again.
+     */
+    readonly serverWork: boolean;
+    /**
+     * A client source, or a configuration file of the client project, changed.
+     * The update inspects the client project again and reuses the server's
+     * inspection.
+     */
+    readonly clientWork: ClientWork | undefined;
+    /**
+     * A file of the public source directory or of the critical CSS changed, or
+     * a `dev.onChange` rule that requests no server restart matched a changed
+     * file. The update captures the static public assets and prepares the critical CSS.
+     */
+    readonly staticWork: StaticWork | undefined;
+};
+type ClientWork = {
+    /** A file that decides how modules resolve, such as `tsconfig.json`, changed, so Vite starts again. */
+    readonly restartsVite: boolean;
+};
+type StaticWork = {
+    /** A matching rule requests `"revalidate-client-data"`. */
+    readonly revalidatesClientData: boolean;
+    /** A matching rule requests `"hard-browser-reload"`. */
+    readonly reloadsBrowser: boolean;
+};
+export declare const NO_DEV_WORK: DevWork;
+/** Static work that asks for neither a revalidation nor a reload. */
+export declare const STATIC_WORK: DevWork;
+export declare function testDevWorkRequested(work: DevWork): boolean;
+/** The work that either argument asks for. */
+export declare function mergeDevWork(first: DevWork, second: DevWork): DevWork;
+export type DevInputs = {
+    readonly sources: DevSourceInputs;
+    readonly configFiles: ReadonlySet<string>;
+    readonly viteConfigFiles: ReadonlySet<string>;
+    readonly criticalCssFiles: ReadonlySet<string>;
+};
+/**
+ * Sorts the changed files of one batch into the updates that they ask for,
+ * and reports whether the batch changed the Vorma configuration or a file that
+ * it imports, which restarts the session. Ordinary browser modules remain
+ * Vite's hot update inputs. A batch that asks for no work asks for nothing.
+ */
+export declare function classifyDevChanges(input: {
+    readonly layout: DevLayout;
+    readonly inputs: DevInputs;
+    readonly changedPaths: ReadonlySet<string>;
+    readonly changeRules: DevChangeRules;
+}): Effect.Effect<{
+    restartsSession: boolean;
+    work: DevWork;
+}, import("../inspection/typescript-projects.ts").TsProjectIssue, Path.Path>;
+export {};

package/dist/build/{client-inputs.d.ts → generation/client-view-entries.d.ts}

@@ -1,10 +1,8 @@
 import type { ApplicationGeneration } from "./generate-application.ts";
-/** Runtime peers that must have one browser identity in development and production. */
-export declare const CLIENT_SHARED_PACKAGES: string[];
 export type ClientViewEntry = {
     readonly pattern: string;
+    /** The view module's id, in the form that Vite's `normalizePath` gives its path; its default export is the view. */
     readonly id: string;
-    readonly exportName: string;
 };
 /** Projects each validated view declaration into one browser entry. */
 export declare function getClientViewEntries(generation: ApplicationGeneration): ReadonlyArray<ClientViewEntry>;

package/dist/build/generation/compile-application.d.ts

@@ -0,0 +1,28 @@
+import { Result } from "effect";
+import type { CompiledNestedPattern } from "primitives-ts/matcher";
+import type { InspectedClientView, InspectedEndpoint, InspectedProjects, InspectedViewLoader } from "../inspection/inspect-projects.ts";
+export type ApplicationView = {
+    /** The authored pattern, as the loader or the view wrote it. */
+    readonly pattern: string;
+    readonly compiledPattern: CompiledNestedPattern;
+    readonly loader: InspectedViewLoader | undefined;
+    readonly clientView: InspectedClientView | undefined;
+    /** The input types of the loaders from the chain root to this view, as type text, in chain order; the view's search combines them. */
+    readonly chainLoaderInputs: ReadonlyArray<string>;
+    /** The authored patterns of the views nested directly in this one; this view's child error component renders their failures. */
+    readonly childPatterns: ReadonlyArray<string>;
+};
+export type ApplicationModel = {
+    readonly viewLoaders: ReadonlyArray<InspectedViewLoader>;
+    readonly endpoints: ReadonlyArray<InspectedEndpoint>;
+    readonly clientViews: ReadonlyArray<InspectedClientView>;
+    /** The view modules in stable order, for generated type imports. */
+    readonly clientViewModules: ReadonlyArray<string>;
+    readonly views: ReadonlyArray<ApplicationView>;
+};
+/** A problem that stops the build from generating types; the message names every declaration involved. */
+export type ApplicationModelIssue = {
+    readonly msg: string;
+};
+/** Joins the inspected declarations and views into one model. */
+export declare function compileApplicationModel(inspection: InspectedProjects): Result.Result<ApplicationModel, ReadonlyArray<ApplicationModelIssue>>;

package/dist/build/generation/generate-application.d.ts

@@ -0,0 +1,52 @@
+import { Effect } from "effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import type { ChildProcessSpawner } from "effect/process";
+import { type StaticPublicAssetIssue, type StaticPublicAssetProjection } from "../assets/static-public-assets.ts";
+import type { ConfigResolutionIssue } from "../config/resolve-config.ts";
+import type { ApplicationSourceLayout, ApplicationSourceLayoutIssues } from "../config/source-layout.ts";
+import type { InspectedProjects, InspectionIssues } from "../inspection/inspect-projects.ts";
+import type { TsProjectIssue } from "../inspection/typescript-projects.ts";
+import { type ApplicationModel, type ApplicationModelIssue } from "./compile-application.ts";
+import type { GeneratedSource } from "./render-source-text.ts";
+export type ApplicationModelIssues = {
+    readonly _tag: "ApplicationModelIssues";
+    readonly issues: ReadonlyArray<ApplicationModelIssue>;
+};
+/** The `staticPublicAssets` lookups that name assets the static public asset directory does not contain. */
+export type UnknownStaticPublicAssetKeys = {
+    readonly _tag: "UnknownStaticPublicAssetKeys";
+    readonly issues: ReadonlyArray<{
+        readonly msg: string;
+    }>;
+};
+export type GeneratedApplicationWriteIssue = {
+    readonly _tag: "GeneratedApplicationWriteIssue";
+    readonly filePath: string;
+    readonly msg: string;
+    readonly cause: unknown;
+};
+export type ApplicationGenerationIssue = ConfigResolutionIssue | StaticPublicAssetIssue | TsProjectIssue | InspectionIssues | ApplicationSourceLayoutIssues | ApplicationModelIssues | UnknownStaticPublicAssetKeys;
+export type ApplicationGeneration = {
+    readonly sourceLayout: ApplicationSourceLayout;
+    readonly model: ApplicationModel;
+    readonly inspection: InspectedProjects;
+    /** The client project's generated types, at the configured `client.tsGenOutFile`. */
+    readonly clientTypes: GeneratedSource;
+    readonly staticPublicAssets: StaticPublicAssetProjection;
+};
+/** Reads the server's contract and the client project, captures static public assets, and prepares generated build inputs without publishing them. */
+export declare function prepareApplicationGeneration(sourceLayout: ApplicationSourceLayout): Effect.Effect<ApplicationGeneration, ApplicationGenerationIssue, FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner>;
+/** Reads declarations and static public asset lookups independently of static public asset hashing. */
+export declare function inspectApplicationSources(sourceLayout: ApplicationSourceLayout): Effect.Effect<InspectedProjects, TsProjectIssue | {
+    _tag: "InspectionIssues";
+    issues: import("../inspection/inspect-projects.ts").InspectionIssue[];
+}, ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Path.Path>;
+/** Prepares correlated build inputs from an inspection and a captured public directory. */
+export declare function assembleApplicationGeneration(input: {
+    readonly sourceLayout: ApplicationSourceLayout;
+    readonly inspection: InspectedProjects;
+    readonly staticPublicAssets: StaticPublicAssetProjection;
+}): Effect.Effect<ApplicationGeneration, ApplicationModelIssues | UnknownStaticPublicAssetKeys, Path.Path>;
+/** Writes the client's generated types file, replacing it atomically. */
+export declare function writeApplicationGeneration(generation: ApplicationGeneration): Effect.Effect<void, GeneratedApplicationWriteIssue, FileSystem.FileSystem | Path.Path>;

package/dist/build/generation/render-client-contracts.d.ts

@@ -0,0 +1,15 @@
+import type * as Path from "effect/Path";
+import { type StaticPublicAssetProjection } from "../assets/static-public-assets.ts";
+import type { InspectedProjects } from "../inspection/inspect-projects.ts";
+import type { ApplicationModel } from "./compile-application.ts";
+import { type GeneratedSource } from "./render-source-text.ts";
+/** An identifier that the generated file declares or imports, besides the server's named declarations. */
+export declare function testGeneratedClientIdentifier(name: string): boolean;
+/** Renders the augmentation of `VormaGeneratedTypes` with the fields `views`, `apiEndpoints`, and `assets`. */
+export declare function renderGeneratedClientTypes(input: {
+    readonly model: ApplicationModel;
+    readonly inspection: InspectedProjects;
+    readonly staticPublicAssets: StaticPublicAssetProjection;
+    readonly filePath: string;
+    readonly path: Path.Path;
+}): GeneratedSource;

package/dist/build/{render-source-text.d.ts → generation/render-source-text.d.ts}

@@ -1,22 +1,18 @@
-import type { Schema } from "effect";
 import type * as Path from "effect/Path";
 export type GeneratedSource = {
     readonly filePath: string;
     readonly source: string;
 };
+export declare const GENERATED_SOURCE_HEADER = "// Code generated by Vorma. DO NOT EDIT.";
 /** A tab-indented prefix, matching how a person writes generated source. */
 export declare function toIndent(depth: number): string;
 /** Moves multi-line rendered text deeper by `depth` tabs; the first line keeps its position in the line that embeds it. */
 export declare function indentRenderedText(text: string, depth: number): string;
-export declare function renderPropertyName(name: string): string;
-export declare function renderStringLiteral(value: string): string;
-/** Renders a JSON value as source a person would have written, at the given tab depth for its inner lines. */
-export declare function renderDataValue(value: Schema.Json, depth: number): string;
 /** The path operations module-specifier rendering needs; both Effect Path and node:path satisfy it. */
-export type SpecifierPath = Pick<Path.Path, "dirname" | "relative" | "sep">;
+export type SpecifierPathOperations = Pick<Path.Path, "dirname" | "relative" | "sep">;
 /** A relative module specifier, explicitly relative even when the target's own name starts with a dot. */
 export declare function getModuleSpecifier(input: {
-    readonly path: SpecifierPath;
+    readonly path: SpecifierPathOperations;
     readonly fromFilePath: string;
     readonly toFilePath: string;
 }): string;

package/dist/build/inspection/http-method.d.ts

@@ -0,0 +1,4 @@
+import * as NativeHttpMethod from "effect/http/HttpMethod";
+/** Methods supported by Vorma's browser-facing endpoint protocol. */
+export type HttpMethod = Exclude<NativeHttpMethod.HttpMethod, "HEAD" | "TRACE">;
+export declare function testHttpMethod(method: unknown): method is HttpMethod;

package/dist/build/inspection/inspect-application.d.ts

@@ -0,0 +1,25 @@
+import { Effect } from "effect";
+import type { APIOptions, Project } from "typescript/unstable/async";
+import type { ApplicationSourceLayout } from "../config/source-layout.ts";
+import { type InspectedProjects, type InspectionIssues, type ServerInspection } from "./inspect-projects.ts";
+/**
+ * Inspects the application and passes the result to `useFn` while the client
+ * checker session is open. `readServer` reads the Rust server's declarations
+ * while the client is inspected, and `useFn` receives what it yields. When
+ * both inspections find issues, the failure reports them together.
+ */
+export declare function withApplicationInspection<Server extends {
+    readonly inspection: ServerInspection;
+}, A, E, R, ServerR>(input: {
+    readonly layout: ApplicationSourceLayout;
+    readonly readServer: Effect.Effect<Server, InspectionIssues, ServerR>;
+    readonly fileSystem?: APIOptions["fs"];
+    readonly useFn: (inspected: {
+        readonly inspection: InspectedProjects;
+        readonly client: Project;
+        readonly server: Server;
+    }) => Effect.Effect<A, E, R>;
+}): Effect.Effect<A, E | import("./typescript-projects.ts").TsProjectIssue | {
+    _tag: "InspectionIssues";
+    issues: import("./inspect-projects.ts").InspectionIssue[];
+}, Exclude<R, import("effect/Scope").Scope> | Exclude<ServerR, import("effect/Scope").Scope>>;

package/dist/build/inspection/inspect-projects.d.ts

@@ -0,0 +1,85 @@
+import { Effect } from "effect";
+import { type Project } from "typescript/unstable/async";
+import type { ApplicationSourceLayout } from "../config/source-layout.ts";
+import type { HttpMethod } from "./http-method.ts";
+import type { TypeDeclarations } from "./type-declarations.ts";
+import { type TsProjectIssue } from "./typescript-projects.ts";
+export type InspectedViewLoader = {
+    readonly kind: "ViewLoader";
+    readonly pattern: string;
+    /** Where the app lists the loader, as issue messages name it. */
+    readonly location: string;
+    /** The input type as TypeScript text; absent when the loader takes no input. */
+    readonly input: string | undefined;
+    /** The output type as TypeScript text; absent when the loader has no output. */
+    readonly output: string | undefined;
+    readonly errors: ReadonlyArray<InspectedDeclaredError>;
+};
+/** One declared error of a view loader or an endpoint. */
+export type InspectedDeclaredError = {
+    /** The declared error type as TypeScript text. */
+    readonly typeText: string;
+};
+/** How an endpoint receives its input. */
+export type InputTransportKind = "none" | "search" | "json" | "formData";
+export type InspectedEndpoint = {
+    readonly kind: "Endpoint";
+    readonly operation: "query" | "mutation";
+    readonly method: HttpMethod;
+    readonly pattern: string;
+    /** Where the app lists the endpoint, as issue messages name it. */
+    readonly location: string;
+    /** The input type as TypeScript text; absent when the endpoint takes no input. For form data it is the form's fields. */
+    readonly input: string | undefined;
+    readonly inputTransport: InputTransportKind;
+    /** The output type as TypeScript text; absent when the endpoint has no output. */
+    readonly output: string | undefined;
+    readonly errors: ReadonlyArray<InspectedDeclaredError>;
+};
+export type InspectedServerDeclaration = InspectedViewLoader | InspectedEndpoint;
+export type InspectedClientView = {
+    /** The view file. */
+    readonly filePath: string;
+    readonly pattern: string;
+    /** Whether the file's default export is the view itself or an array that contains it. */
+    readonly defaultExportShape: "View" | "ViewArray";
+    /** Where the file exports the view, as issue messages name it. */
+    readonly location: string;
+};
+/** A `staticPublicAssets` lookup: the span to replace and the asset key it names. */
+export type StaticPublicAssetLookup = {
+    /** Where the call is, as issue messages name it. */
+    readonly location: string;
+    readonly filePath: string;
+    readonly start: number;
+    readonly end: number;
+    readonly key: string;
+};
+export type InspectedProjects = {
+    /** Every view loader and endpoint of the application, in the order of their contract identities. */
+    readonly serverDeclarations: ReadonlyArray<InspectedServerDeclaration>;
+    readonly clientViews: ReadonlyArray<InspectedClientView>;
+    readonly staticPublicAssetLookups: ReadonlyArray<StaticPublicAssetLookup>;
+    /** The text of every client file that has a static public asset lookup, as the checker read it. */
+    readonly clientSourceTexts: ReadonlyMap<string, string>;
+    /** The named type declarations that the declarations' type texts reference. */
+    readonly typeDeclarations: TypeDeclarations;
+    /** The server binary's hash of its declarations, which the build directory records. */
+    readonly declarationsHash: string;
+};
+export type InspectionIssue = {
+    readonly msg: string;
+};
+export type InspectionIssues = {
+    readonly _tag: "InspectionIssues";
+    readonly issues: ReadonlyArray<InspectionIssue>;
+};
+/** A server's declarations and the named type declarations that their type texts reference. */
+export type ServerInspection = Pick<InspectedProjects, "serverDeclarations" | "typeDeclarations" | "declarationsHash">;
+/** What the client project contributes to an inspection. */
+export type ClientInspection = Omit<InspectedProjects, keyof ServerInspection>;
+/** Reads the client project's views and every lookup of a static public asset. */
+export declare function inspectClientProject(input: {
+    readonly client: Project;
+    readonly layout: ApplicationSourceLayout;
+}): Effect.Effect<ClientInspection, InspectionIssues | TsProjectIssue>;