@sjcx/vorma 0.0.0-pre.5 → 0.0.0-pre.7

package/dist/build/config/load-config.d.ts

@@ -0,0 +1,142 @@
+import { Effect, Path } from "effect";
+import { type VormaConfig } from "../../config.ts";
+export type ConfigLoadIssue = {
+    readonly _tag: "ConfigLoadIssue";
+    readonly msg: string;
+    readonly cause?: unknown;
+};
+/**
+ * Decodes an authored Vorma configuration. The decoder rejects a key that the
+ * schema does not define.
+ */
+export declare function decodeVormaConfig(input: {
+    readonly authored: unknown;
+    readonly configFilePath: string;
+}): Effect.Effect<VormaConfig, ConfigLoadIssue>;
+/**
+ * Loads the Vorma configuration file that a command names, decodes it, and
+ * resolves it. A process calls this once and passes the result on. Vite's
+ * loader retains the configuration's own `import.meta.url`, so
+ * `core.importMetaUrl` must identify the loaded file.
+ */
+export declare function loadVormaConfig(input: {
+    readonly configPath: string;
+    readonly cmd: "build" | "serve";
+    readonly mode: "production" | "development";
+}): Effect.Effect<{
+    config: {
+        readonly core: {
+            readonly importMetaUrl: string;
+            readonly distDir: string;
+            readonly staticPublicAssets: {
+                readonly srcDir: string;
+                readonly serveUrlPathPrefix: string;
+            };
+        };
+        readonly build: {
+            readonly serverStartCmd: readonly [string, ...string[]];
+        };
+        readonly client: {
+            readonly tsConfigFile: string;
+            readonly viteConfigFile: string;
+            readonly tsGenOutFile: string;
+            readonly criticalCssFile?: string;
+            readonly entryFile: string;
+            readonly viewFilePattern: string;
+        };
+        readonly dev?: {
+            readonly server: {
+                readonly cargoManifestFile: string;
+                readonly cargoBin: string;
+                readonly cargoArgs?: readonly string[];
+                readonly binArgs?: readonly string[];
+                readonly wrapCmdFn?: (input: {
+                    readonly executable: string;
+                    readonly args: ReadonlyArray<string>;
+                }) => readonly [string, ...string[]];
+                readonly preferredPort?: number;
+            };
+            readonly onChange?: readonly {
+                readonly triggers: readonly [string, ...string[]];
+                readonly actions: readonly ["hard-browser-reload" | "restart-server" | "revalidate-client-data", ...("hard-browser-reload" | "restart-server" | "revalidate-client-data")[]];
+            }[];
+        };
+    };
+    resolved: import("./resolve-config.ts").ResolvedVormaConfig;
+    configFilePath: string;
+    /** The configuration file and the files that it imports. */
+    dependencies: string[];
+}, ConfigLoadIssue | import("./resolve-config.ts").ConfigResolutionIssue, Path.Path>;
+/** Loads and checks the authored Vite configuration before Vorma applies its settings. */
+export declare function checkViteConfig(input: {
+    readonly configFilePath: string;
+    readonly viteConfigFilePath: string;
+    readonly cmd: "build" | "serve";
+    readonly mode: "production" | "development";
+}): Effect.Effect<undefined, ConfigLoadIssue, Path.Path>;
+/**
+ * Loads the configuration for `vorma dev`, which requires `dev`. The
+ * configuration file and its dependencies restart the whole development
+ * session; Vite restarts itself for the dependencies of its own configuration.
+ */
+export declare function loadDevConfig(configPath: string): Effect.Effect<{
+    configFilePath: string;
+    /** The configuration file and the files that it imports. */
+    dependencies: string[];
+    config: {
+        core: {
+            readonly importMetaUrl: string;
+            readonly distDir: string;
+            readonly staticPublicAssets: {
+                readonly srcDir: string;
+                readonly serveUrlPathPrefix: string;
+            };
+        };
+        build: {
+            readonly serverStartCmd: readonly [string, ...string[]];
+        };
+        client: {
+            readonly tsConfigFile: string;
+            readonly viteConfigFile: string;
+            readonly tsGenOutFile: string;
+            readonly criticalCssFile?: string;
+            readonly entryFile: string;
+            readonly viewFilePattern: string;
+        };
+        dev: {
+            readonly server: {
+                readonly cargoManifestFile: string;
+                readonly cargoBin: string;
+                readonly cargoArgs?: readonly string[];
+                readonly binArgs?: readonly string[];
+                readonly wrapCmdFn?: (input: {
+                    readonly executable: string;
+                    readonly args: ReadonlyArray<string>;
+                }) => readonly [string, ...string[]];
+                readonly preferredPort?: number;
+            };
+            readonly onChange?: readonly {
+                readonly triggers: readonly [string, ...string[]];
+                readonly actions: readonly ["hard-browser-reload" | "restart-server" | "revalidate-client-data", ...("hard-browser-reload" | "restart-server" | "revalidate-client-data")[]];
+            }[];
+        };
+    };
+    resolved: {
+        buildDir: string;
+        publicDir: string;
+        buildMetadataFilePath: string;
+        configFilePath: string;
+        configDir: string;
+        serverStartCmd: VormaConfig["build"]["serverStartCmd"];
+        clientTsConfigFilePath: string;
+        clientEntryFilePath: string;
+        viewFilePattern: string;
+        clientTypesFilePath: string;
+        staticPublicAssetsSourceDir: string;
+        viteConfigFilePath: string;
+        criticalCssEntryFilePath?: string;
+        staticPublicAssetsServeUrlPathPrefix: import("./resolve-config.ts").StaticPublicAssetsServeUrlPathPrefix;
+        distDir: string;
+        dev: import("./resolve-config.ts").ResolvedDev;
+    };
+}, ConfigLoadIssue | import("./resolve-config.ts").ConfigResolutionIssue, Path.Path>;

package/dist/build/config/resolve-config.d.ts

@@ -0,0 +1,63 @@
+import { Effect } from "effect";
+import * as Path from "effect/Path";
+import type { VormaConfig } from "../../config.ts";
+import { type BuildDirPaths } from "../output/dist-dir.ts";
+export type StaticPublicAssetsServeUrlPathPrefix = "/" | `/${string}/`;
+type DevConfig = NonNullable<VormaConfig["dev"]>;
+/** The server that `vorma dev` compiles and runs, with its paths resolved. */
+export type ResolvedDevServer = Omit<DevConfig["server"], "cargoManifestFile" | "cargoArgs" | "binArgs"> & {
+    /** The server's Cargo manifest. */
+    readonly cargoManifestFilePath: string;
+    /** The Cargo binary target that serves the Vorma app. */
+    readonly cargoBin: string;
+    readonly cargoArgs: ReadonlyArray<string>;
+    readonly binArgs: ReadonlyArray<string>;
+};
+export type ResolvedDev = Omit<DevConfig, "server"> & {
+    readonly server: ResolvedDevServer;
+    /** The build directory of `vorma dev`, in the dist directory, which the development server reads. */
+    readonly buildDir: string;
+};
+export type ResolvedVormaConfig = {
+    /** The configuration file that `core.importMetaUrl` identifies. */
+    readonly configFilePath: string;
+    /** The directory of the configuration file; every configured path is relative to it. */
+    readonly configDir: string;
+    /** The command that `vorma build` runs to read the application's declarations. */
+    readonly serverStartCmd: VormaConfig["build"]["serverStartCmd"];
+    readonly clientTsConfigFilePath: string;
+    readonly clientEntryFilePath: string;
+    /**
+     * The configured view file pattern, with forward slashes. It is relative to
+     * `configDir` unless it is absolute, so that matching it never reads a
+     * glob character of the directory path as part of the pattern.
+     */
+    readonly viewFilePattern: string;
+    /** Where the build writes the client project's generated types. */
+    readonly clientTypesFilePath: string;
+    readonly staticPublicAssetsSourceDir: string;
+    /** The Vite configuration that Vorma's commands load; its Vorma plugin receives this configuration. */
+    readonly viteConfigFilePath: string;
+    readonly criticalCssEntryFilePath?: string;
+    readonly staticPublicAssetsServeUrlPathPrefix: StaticPublicAssetsServeUrlPathPrefix;
+    /** The configured dist directory, which holds the build directory of `vorma build` and the build directory of `vorma dev`. */
+    readonly distDir: string;
+    readonly dev: ResolvedDev | undefined;
+} & BuildDirPaths;
+export type ConfigResolutionIssue = {
+    readonly _tag: "ConfigResolutionIssue";
+    readonly field: "core.importMetaUrl" | "core.staticPublicAssets.serveUrlPathPrefix";
+    readonly msg: string;
+    readonly cause?: unknown;
+};
+/**
+ * Resolves every configured path once against the configuration file's
+ * directory. The configuration is decoded before this call.
+ */
+export declare function resolveVormaConfig(config: VormaConfig & {
+    readonly dev: DevConfig;
+}): Effect.Effect<ResolvedVormaConfig & {
+    readonly dev: ResolvedDev;
+}, ConfigResolutionIssue, Path.Path>;
+export declare function resolveVormaConfig(config: VormaConfig): Effect.Effect<ResolvedVormaConfig, ConfigResolutionIssue, Path.Path>;
+export {};

package/dist/build/{source-layout.d.ts → config/source-layout.d.ts}

@@ -6,19 +6,17 @@ declare const APPLICATION_SOURCE_LAYOUT_BRAND: unique symbol;
 export type ApplicationSourceLayout = ResolvedVormaConfig & {
     readonly [APPLICATION_SOURCE_LAYOUT_BRAND]: true;
 };
-export type ApplicationSourcePathField = "serverTsconfigFile" | "clientEntry" | "clientTsconfigFile" | "publicAssetsDir" | "viteConfigFile" | "criticalCssEntry";
+/** The configuration key that names a path. */
+export type ApplicationSourcePathField = "dev.server.cargoManifestFile" | "client.tsConfigFile" | "client.viteConfigFile" | "client.entryFile" | "client.criticalCssFile" | "client.tsGenOutFile" | "core.staticPublicAssets.srcDir" | "core.distDir";
 export type ApplicationSourceLayoutIssue = {
     readonly field: ApplicationSourcePathField;
     readonly path: string;
-    readonly expectedType: "File" | "Directory";
-    readonly actualType?: FileSystem.File.Type;
-    readonly message?: string;
-    readonly cause?: unknown;
+    readonly msg: string;
 };
 export type ApplicationSourceLayoutIssues = {
     readonly _tag: "ApplicationSourceLayoutIssues";
     readonly issues: ReadonlyArray<ApplicationSourceLayoutIssue>;
 };
 /** Loads the configured source layout before any application module executes. */
-export declare function loadApplicationSourceLayout(config: ResolvedVormaConfig): Effect.Effect<ApplicationSourceLayout, ApplicationSourceLayoutIssues, FileSystem.FileSystem | Path.Path>;
+export declare function loadApplicationSourceLayout<Config extends ResolvedVormaConfig>(config: Config): Effect.Effect<ApplicationSourceLayout & Config, ApplicationSourceLayoutIssues, FileSystem.FileSystem | Path.Path>;
 export {};

package/dist/build/config/url-pathname.d.ts

@@ -0,0 +1,13 @@
+import { Result } from "effect";
+declare const URL_PATHNAME_BRAND: unique symbol;
+export type UrlPathname = string & {
+    readonly [URL_PATHNAME_BRAND]: true;
+};
+export type UrlPathnameParseIssue = {
+    readonly _tag: "UrlPathnameParseIssue";
+    readonly value: string;
+    readonly cause?: unknown;
+};
+/** Parses the exact pathname representation used for request classification. */
+export declare function parseUrlPathname(value: string): Result.Result<UrlPathname, UrlPathnameParseIssue>;
+export {};

package/dist/build/config/vite-options.d.ts

@@ -0,0 +1,80 @@
+import type { Server } from "node:http";
+/** The loopback address of Vorma's module server, from which development documents load browser modules. */
+export declare const MODULE_SERVER_HOST = "127.0.0.1";
+/**
+ * Vite runs in middleware mode inside Vorma's module server: it serves browser
+ * modules and hot updates on that server's port, and its WebSocket connection
+ * uses the same server.
+ */
+export declare function createDevViteOptions(input: {
+    /** `http://127.0.0.1:<port>`. */
+    readonly origin: string;
+    readonly port: number;
+    readonly server: Server;
+}): {
+    base: string;
+    publicDir: false;
+    appType: "custom";
+    server: {
+        middlewareMode: true;
+        origin: string;
+        ws: {
+            server: Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse>;
+            protocol: string;
+            host: string;
+            port: number;
+            clientPort: number;
+        };
+    };
+};
+/** A production build serves its hashed files at the static public assets path and writes no Vite public directory. */
+export declare function createBuildViteOptions(input: {
+    readonly base: string;
+}): {
+    base: string;
+    publicDir: false;
+};
+/**
+ * The client environment builds exactly `inputs`, the client entry, the view
+ * modules, and the critical CSS entry, and writes ES modules into the build
+ * directory's public directory, which Vorma clears itself. Every output name
+ * carries a content hash and Vorma's prefix.
+ */
+export declare function createClientBuildViteOptions(input: {
+    readonly outDir: string;
+    /** The source files that the build starts from. Rolldown names each output after its file. */
+    readonly inputs: ReadonlyArray<string>;
+}): {
+    build: {
+        outDir: string;
+        emptyOutDir: false;
+        write: true;
+        assetsDir: string;
+        cssCodeSplit: true;
+        rolldownOptions: {
+            input: string[];
+            preserveEntrySignatures: "strict";
+            output: {
+                format: "es";
+                dir: string;
+                entryFileNames: "vorma_out_[name]-[hash].js";
+                chunkFileNames: "vorma_out_[name]-[hash].js";
+                assetFileNames: "vorma_out_[name]-[hash][extname]";
+            };
+        };
+    };
+};
+/**
+ * One message for each option of an authored Vite configuration that has no
+ * effect under Vorma: an option that Vorma sets itself, and an option that
+ * applies only when Vite owns a server or performs server-side rendering.
+ * Options that act on Vite's module serving in middleware mode, such as
+ * `server.cors`, `server.fs`, `server.proxy`, and `server.hmr.overlay`, are
+ * not reported.
+ */
+export declare function findViteOptionsWithoutEffect(input: {
+    /** The Vite configuration as its file exports it, before plugins apply. */
+    readonly config: object;
+    /** How messages name the Vite configuration file. */
+    readonly fileName: string;
+}): ReadonlyArray<string>;

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

@@ -0,0 +1,18 @@
+import { type Cause, Effect } from "effect";
+import type { ResolvedDevServer } from "../config/resolve-config.ts";
+export declare function superviseApplicationProcess(input: {
+    readonly server: Pick<ResolvedDevServer, "binArgs" | "wrapCmdFn">;
+    readonly configDir: string;
+    readonly port: number;
+    /** The dist directory, in which the server reads the build directory of `vorma dev`. */
+    readonly distDir: string;
+}): Effect.Effect<{
+    start: (launch: {
+        readonly executable: string;
+        readonly expectedClientBuildId: string;
+    }) => Effect.Effect<void, unknown, import("effect/process/ChildProcessSpawner").ChildProcessSpawner>;
+    stop: Effect.Effect<void, never, never>;
+    testProcessRunning: () => boolean;
+    /** Reports each started process's unrequested exit. */
+    unexpectedExit: Effect.Effect<Cause.Cause<unknown>, never, never>;
+}, never, import("effect/Scope").Scope>;

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

@@ -0,0 +1,37 @@
+import { type ClientModule } from "../publication/build-metadata.ts";
+import type { DevBuild, DevClient } from "./build.ts";
+import type { IndexHtmlParts } from "./index-html.ts";
+export declare function toDevModuleUrl(input: {
+    readonly origin: string;
+    readonly root: string;
+    readonly id: string;
+}): string;
+/** Keeps source URLs and browser contracts on the server; responses project only requested views. */
+export declare function assembleDevArtifacts(input: {
+    readonly build: DevBuild;
+    readonly client: DevClient;
+    readonly indexHtmlParts: IndexHtmlParts;
+}): {
+    metadata: {
+        formatVersion: number;
+        runtimeMode: "dev";
+        clientBuildId: string;
+        declarationsHash: string;
+        staticPublicAssetsServeUrlPathPrefix: import("../config/resolve-config.ts").StaticPublicAssetsServeUrlPathPrefix;
+        staticPublicAssetFileNames: string[];
+        staticPublicAssetUrls: Readonly<Record<string, string>>;
+        criticalCss: string;
+        devCsp: {
+            moduleServerOrigin: string;
+            webSocketOrigin: string;
+            nonce?: string;
+        };
+        devHeadHtml?: string;
+        devBodyPrependHtml?: string;
+        devBodyHtml?: string;
+        clientEntry: ClientModule;
+        clientViews: {
+            [k: string]: ClientModule;
+        };
+    };
+};

package/dist/build/dev/browser-source.d.ts

@@ -0,0 +1,25 @@
+export declare const DEV_BROWSER_MODULE = "\0vorma:development-browser";
+/** The Vite HMR event that carries the session's messages to the browser module below. */
+export declare const DEV_BROWSER_EVENT = "vorma:development";
+/**
+ * What the session tells the browser. `full-reload` is Vite's own reload
+ * message; the other kinds travel on `DEV_BROWSER_EVENT` and the
+ * browser module below handles each one.
+ */
+export type DevBrowserMsg = {
+    readonly kind: "full-reload";
+} | {
+    readonly kind: "rebuilding";
+} | {
+    readonly kind: "error";
+    readonly msg: string;
+} | {
+    readonly kind: "css";
+    readonly css: string;
+} | {
+    readonly kind: "revalidate";
+} | {
+    readonly kind: "ready";
+};
+/** Browser-only development controls use Vite's authenticated HMR connection. */
+export declare function renderDevBrowserSource(): string;

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

@@ -0,0 +1,33 @@
+import { Effect } from "effect";
+import type { startDevClient } from "./client.ts";
+import type { DevLayout } from "./generated-paths.ts";
+import type { DevGeneration } from "./generation.ts";
+import type { DevWork } from "./work.ts";
+export type DevClient = Effect.Success<ReturnType<typeof startDevClient>>;
+export type DevBuild = {
+    readonly generation: DevGeneration;
+    readonly stylesheet: {
+        readonly css: string;
+        readonly inputFilePaths: ReadonlyArray<string>;
+    };
+};
+/**
+ * Prepares native CSS after the generation's public-asset inputs exist. A
+ * later build gives Vite the generation's inputs first, and reads the critical
+ * CSS again unless its work is client work alone.
+ */
+export declare function prepareDevBuild(input: {
+    readonly layout: DevLayout;
+    readonly generation: DevGeneration;
+    readonly client: DevClient;
+    readonly previous?: {
+        readonly build: DevBuild;
+        readonly work: DevWork;
+    };
+}): Effect.Effect<{
+    generation: DevGeneration;
+    stylesheet: {
+        readonly css: string;
+        readonly inputFilePaths: ReadonlyArray<string>;
+    };
+}, import("./stylesheet.ts").DevStylesheetIssue, never>;

package/dist/build/dev/cargo-metadata.d.ts

@@ -0,0 +1,28 @@
+import { Effect } from "effect";
+/** What Cargo reports for the server's manifest that development reads. */
+export type CargoMetadata = {
+    /** The directory into which Cargo builds, which every build writes. */
+    readonly targetDir: string;
+    /** The workspace root, which holds `Cargo.lock` and the root `Cargo.toml`. */
+    readonly workspaceRoot: string;
+};
+/** Cargo could not report its metadata; the message includes Cargo's own output. */
+export type CargoMetadataIssue = {
+    readonly _tag: "CargoMetadataIssue";
+    readonly msg: string;
+};
+/**
+ * Cargo's target directory and workspace root for a manifest. Cargo resolves
+ * the target directory from `CARGO_TARGET_DIR`, its configuration files, and
+ * the workspace root.
+ */
+export declare function readCargoMetadata(input: {
+    readonly cargoManifestFilePath: string;
+    readonly configDir: string;
+}): Effect.Effect<{
+    targetDir: string;
+    workspaceRoot: string;
+}, {
+    _tag: "CargoMetadataIssue";
+    msg: string;
+}, import("effect/process/ChildProcessSpawner").ChildProcessSpawner>;

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

@@ -0,0 +1,11 @@
+import { Effect } from "effect";
+/**
+ * Batches native watcher events after 30 ms without another event. Completed
+ * batches accumulate while the consumer is busy; no changed path is discarded.
+ * A watcher error is logged, and watching continues.
+ */
+export declare function createDevChanges(): Effect.Effect<{
+    take: Effect.Effect<ReadonlySet<string>, never, never>;
+    recordChange: (filePath: string) => void;
+    recordError: (cause: unknown) => void;
+}, never, import("effect/Scope").Scope>;

package/dist/build/dev/client-inputs.d.ts

@@ -0,0 +1,25 @@
+import type { ApplicationGeneration } from "../generation/generate-application.ts";
+import type { DevLayout } from "./generated-paths.ts";
+import type { DevSourceInputs } from "./sources.ts";
+/** Inspected build information stays in the orchestrator, never in a browser manifest. */
+export type DevClientInputs = ReturnType<typeof toDevClientInputs>;
+export declare function toDevClientInputs(input: {
+    readonly layout: DevLayout;
+    readonly generation: ApplicationGeneration;
+    readonly sources: DevSourceInputs;
+}): {
+    configFilePath: string;
+    viteConfigFilePath: string;
+    clientEntryFilePath: string;
+    clientViewModules: readonly string[];
+    coordinatedResolutionFiles: ReadonlySet<string>;
+    generatedPaths: readonly string[];
+    views: readonly import("../generation/client-view-entries.ts").ClientViewEntry[];
+    staticPublicAssetLookups: readonly import("../inspection/inspect-projects.ts").StaticPublicAssetLookup[];
+    clientSourceTexts: {
+        [k: string]: string;
+    };
+    staticPublicAssets: readonly import("../assets/static-public-assets.ts").StaticPublicAsset[];
+    staticPublicAssetUrls: Readonly<Record<string, string>>;
+    publicDir: string;
+};

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

@@ -0,0 +1,39 @@
+import { Effect } from "effect";
+import { type ViteDevServer } from "vite";
+import type { DevClientInputs } from "./client-inputs.ts";
+import { type IndexHtmlParts } from "./index-html.ts";
+import { type DevModuleServerAddress } from "./module-server.ts";
+export type DevClientIssue = {
+    readonly _tag: "DevClientIssue";
+    readonly operation: "create" | "listen" | "close";
+    readonly cause: unknown;
+};
+/** Starts Vite for one inspected application; the surrounding Effect scope closes it. */
+export declare function startDevClient(input: {
+    readonly inputs: DevClientInputs;
+    readonly address: DevModuleServerAddress;
+    readonly recordChangeFn: (filePath: string) => void;
+    /** Called when Vite has restarted itself, such as after a change to the Vite configuration. */
+    readonly onNativeRestartFn: () => void;
+    /** The Vorma configuration and its dependencies; a change restarts the session, not Vite alone. */
+    readonly configFiles: ReadonlySet<string>;
+}): Effect.Effect<{
+    server: ViteDevServer;
+    restart: Effect.Effect<void, import("effect/Cause").UnknownError, never>;
+    origin: string;
+    webSocketOrigin: string;
+    /** The value of Vite's `html.cspNonce`, which reaches the development head. */
+    readonly cspNonce: string | undefined;
+    listen: Effect.Effect<void, import("./module-server.ts").DevModuleServerIssue, never>;
+    readonly views: readonly import("../generation/client-view-entries.ts").ClientViewEntry[];
+    resumeInspection: (shouldReload: boolean) => void;
+    /**
+     * What Vite's plugins add to the document, with every root-relative URL
+     * resolved against the module server. Vite and its plugins emit
+     * root-relative URLs for backend HTML integration. The head also carries
+     * the development browser module.
+     */
+    readIndexHtmlParts: Effect.Effect<IndexHtmlParts, DevClientIssue, never>;
+    /** Replaces inspected sources and asset references within the existing Vite configuration. */
+    updateInputs(next: DevClientInputs): void;
+}, DevClientIssue, import("effect/Scope").Scope>;

package/dist/build/dev/dev-protocol.d.ts

@@ -0,0 +1,23 @@
+/** Process-environment names that the server reads. */
+export declare const PROCESS_ENV_PROTOCOL: {
+    /**
+     * The dist directory, in a process that `vorma dev` started. The server
+     * reads its build from the build directory of `vorma dev` in it.
+     * `vorma dev` sets the variable for the server that it starts. A server in
+     * any other process ignores it and reads the application's
+     * `prod_dist_dir`.
+     */
+    readonly distDirEnvVar: "VORMA_DIST_DIR";
+};
+/** Private development coordination between the launcher and the application process. */
+export declare const DEV_PROTOCOL: {
+    readonly serverPortEnvVar: "PORT";
+    /** Set to "1" in a process that `vorma dev` started; `getIsDev` reads it. */
+    readonly devProcessEnvVar: "__VORMA_IS_DEV";
+    /**
+     * Vorma's handler answers a GET of this path in development with 200 and
+     * its build ID; `vorma dev` treats a replacement process as ready only
+     * after that answer.
+     */
+    readonly readinessPath: "/.vorma/healthz";
+};

package/dist/build/dev/generated-paths.d.ts

@@ -0,0 +1,27 @@
+import type { ResolvedDev } from "../config/resolve-config.ts";
+import type { ApplicationSourceLayout } from "../config/source-layout.ts";
+import type { CargoMetadata } from "./cargo-metadata.ts";
+/**
+ * The source layout, what Cargo reports for the server's manifest, and the
+ * paths that development writes, all of which only development reads.
+ * `buildDir`, `publicDir`, and `buildMetadataFilePath` name the build
+ * directory of `vorma dev`, not the build directory of `vorma build`.
+ */
+export type DevLayout = ApplicationSourceLayout & {
+    readonly dev: ResolvedDev;
+    readonly cargo: CargoMetadata;
+    /** See `getGeneratedPaths`. */
+    readonly generatedPaths: ReadonlyArray<string>;
+};
+/**
+ * The paths that `vorma build`, `vorma dev`, and Cargo write: the configured
+ * dist directory, the client's generated types file, and Cargo's target
+ * directory. Their changes never start
+ * development work. `cargoTargetDir` is `undefined` only when Cargo could not
+ * report it, and the session then fails before it runs Cargo.
+ */
+export declare function getGeneratedPaths(input: {
+    readonly distDir: string;
+    readonly clientTypesFilePath: string;
+    readonly cargoTargetDir: string | undefined;
+}): ReadonlyArray<string>;

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

@@ -0,0 +1,31 @@
+import { Effect } from "effect";
+import { type ApplicationGeneration } from "../generation/generate-application.ts";
+import type { DevLayout } from "./generated-paths.ts";
+import { type DevSourceInputs } from "./sources.ts";
+import type { DevWork } from "./work.ts";
+export type DevGeneration = {
+    readonly application: ApplicationGeneration;
+    readonly sources: DevSourceInputs;
+};
+/**
+ * Captures independent source and public inputs concurrently, without
+ * activating a runtime, and writes the generated client types. The first
+ * generation of a session reads every input. A later generation reads only
+ * what its work changes: server work inspects the server and the client
+ * project and captures the static public assets, client work inspects the client
+ * project and reuses the server's inspection, and static work captures the
+ * static public assets and reuses both inspections.
+ */
+export declare function prepareDevGeneration(input: {
+    readonly layout: DevLayout;
+    readonly previous?: {
+        readonly generation: DevGeneration;
+        readonly work: DevWork;
+    };
+}): Effect.Effect<{
+    application: ApplicationGeneration;
+    sources: DevSourceInputs;
+}, import("../generation/generate-application.ts").ApplicationModelIssues | import("../generation/generate-application.ts").GeneratedApplicationWriteIssue | import("../assets/static-public-assets.ts").StaticPublicAssetIssue | import("../inspection/typescript-projects.ts").TsProjectIssue | import("../generation/generate-application.ts").UnknownStaticPublicAssetKeys | {
+    _tag: "InspectionIssues";
+    issues: import("../inspection/inspect-projects.ts").InspectionIssue[];
+}, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/FileSystem").FileSystem | import("effect/Path").Path>;