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

package/dist/build/inspection/rust-server.d.ts

@@ -0,0 +1,57 @@
+import { Effect, FileSystem } from "effect";
+import * as Path from "effect/Path";
+import type { InspectionIssues, ServerInspection } from "./inspect-projects.ts";
+/** An executable and its arguments, run without a shell. */
+type Cmd = readonly [string, ...Array<string>];
+/** A Rust server's declarations and the executable that described them. */
+export type CompiledRustServer = {
+    readonly inspection: ServerInspection;
+    /** The compiled binary; development reads its Cargo dependency file beside it and runs it. */
+    readonly executable: string;
+};
+/**
+ * Runs `cmd` so that the server it starts writes its declaration
+ * contract, and reads the declarations. `vorma build` runs
+ * `build.serverStartCmd` this way.
+ */
+export declare function inspectStartedRustServer(input: {
+    readonly cmd: Cmd;
+    readonly configDir: string;
+}): Effect.Effect<{
+    inspection: ServerInspection;
+}, InspectionIssues, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | FileSystem.FileSystem | Path.Path>;
+/**
+ * Compiles the server binary with Cargo and runs it with `binArgs` to read the
+ * declaration contract. `vorma dev` inspects the server this way and then runs
+ * the same executable.
+ */
+export declare function inspectCompiledRustServer(input: {
+    readonly cargoManifestFilePath: string;
+    readonly cargoBin: string;
+    readonly cargoArgs: ReadonlyArray<string>;
+    readonly binArgs: ReadonlyArray<string>;
+    readonly configDir: string;
+}): Effect.Effect<{
+    inspection: ServerInspection;
+    executable: string;
+}, InspectionIssues, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | FileSystem.FileSystem | Path.Path>;
+/**
+ * Runs `cmd` so that the server it starts loads the build directory
+ * `buildDir`, runs its startup checks, and exits. `vorma build` runs
+ * `build.serverStartCmd` this way after it writes the build directory.
+ */
+export declare function checkStartedRustServer(input: {
+    readonly cmd: Cmd;
+    readonly configDir: string;
+    readonly buildDir: string;
+}): Effect.Effect<undefined, InspectionIssues, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/Scope").Scope>;
+/**
+ * Decodes the declaration contract that the Rust server `serverLabel` wrote. The
+ * contract's version is checked before the rest, so a contract of another
+ * version fails with the version message.
+ */
+export declare function decodeDeclarationContract(input: {
+    readonly text: string;
+    readonly serverLabel: string;
+}): Effect.Effect<ServerInspection, InspectionIssues>;
+export {};

package/dist/build/inspection/type-declarations.d.ts

@@ -0,0 +1,20 @@
+/** The named type declarations of a server's contract, and the names that each declaration and each type text references directly. */
+export type TypeDeclarations = {
+    /** In name order; each declaration is a complete module-local `type` statement at depth zero. */
+    readonly declarations: ReadonlyArray<{
+        readonly name: string;
+        readonly declaration: string;
+        readonly referencedTypeNames: ReadonlySet<string>;
+    }>;
+    readonly typeTexts: ReadonlyMap<string, ReadonlySet<string>>;
+};
+/**
+ * The declarations that the given type texts need, including every
+ * declaration that a needed declaration names, in declaration order. A
+ * generated file declares only these, so that it has no unused declaration
+ * under the application's compiler options.
+ */
+export declare function selectTypeDeclarations(input: {
+    readonly typeDeclarations: TypeDeclarations;
+    readonly typeTexts: Iterable<string>;
+}): ReadonlyArray<string>;

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

@@ -0,0 +1,31 @@
+import { Effect } from "effect";
+import { type APIOptions, type Project } from "typescript/unstable/async";
+export type TsProjectIssue = {
+    readonly _tag: "TsProjectIssue";
+    readonly msg: string;
+    readonly cause?: unknown;
+};
+/** Reads the client project's root files without loading its program or declaration types. */
+export declare function readClientProjectRoots(input: {
+    readonly configDir: string;
+    readonly clientTsConfigFilePath: string;
+}): Effect.Effect<string[], TsProjectIssue, never>;
+/** Opens the configured client project for the duration of `useFn`, then closes the checker session. */
+export declare function withClientProject<A, E, R>(input: {
+    readonly configDir: string;
+    readonly clientTsConfigFilePath: string;
+    /**
+     * Files that the checker reads as empty. Inspection empties the generated
+     * types file, so it reads every build as the first build does and never
+     * depends on a previous build's output.
+     */
+    readonly emptiedFiles: ReadonlyArray<string>;
+    readonly fileSystem?: APIOptions["fs"];
+    readonly useFn: (client: Project) => Effect.Effect<A, E, R>;
+}): Effect.Effect<A, E | TsProjectIssue, R>;
+/**
+ * One request to the compiler. The compiler has no cancellation API, so an
+ * interrupted request stays pending, and the session's release ends the
+ * compiler process.
+ */
+export declare function runTsOperation<Value>(fn: () => Promise<Value>): Effect.Effect<Value, TsProjectIssue, never>;

package/dist/build/issues.d.ts

@@ -0,0 +1,25 @@
+import { Effect } from "effect";
+/** One problem that the build found, described by its message alone. */
+export type VormaBuildIssue = {
+    readonly msg: string;
+};
+/** Every issue that a build found. */
+export type VormaBuildIssues = {
+    readonly _tag: "VormaBuildIssues";
+    readonly issues: ReadonlyArray<VormaBuildIssue>;
+};
+/** A failure that reports one issue, or one that reports several. */
+export type BuildIssueSource = {
+    readonly msg: string;
+} | {
+    readonly issues: ReadonlyArray<{
+        readonly msg: string;
+    }>;
+};
+export declare function toBuildIssues(failure: BuildIssueSource): VormaBuildIssues;
+/** Prints each issue's message on standard error. */
+export declare function printBuildIssues(issues: VormaBuildIssues): Effect.Effect<void>;
+/** A failure of unknown type as build issues, when it is a failure that reports issues. */
+export declare function readBuildIssues(failure: unknown): VormaBuildIssues | undefined;
+/** An underlying failure's own message, for an issue that explains what it prevented. */
+export declare function describeCause(cause: unknown): string;

package/dist/build/{contained-path.d.ts → output/contained-path.d.ts}

@@ -1,29 +1,19 @@
 import type * as Path from "effect/Path";
 /** True when a `path.relative` result names the root or a descendant of it. */
-export declare function containsRelativePath(input: {
+export declare function testRelativePathContained(input: {
     readonly relativePath: string;
     readonly separator: string;
     readonly absolute: boolean;
 }): boolean;
-/**
- * True when a module specifier names a package or one of its subpaths.
- * Relative, absolute, builtin, scheme, drive-letter, and virtual-module
- * specifiers never match; only the caller decides which of those to exclude
- * first.
- */
-export declare function matchesPackageSpecifier(input: {
-    readonly source: string;
-    readonly packageName: string;
-}): boolean;
 /** The path operations a relative POSIX conversion needs. */
-export type PosixRelativePath = Pick<Path.Path, "sep" | "relative">;
+export type PosixRelativePathOperations = Pick<Path.Path, "sep" | "relative">;
 /**
  * A `path.relative` result with platform separators converted to POSIX
  * separators, for generated module specifiers, output keys, and build
  * identities, which are POSIX even when the build runs on Windows.
  */
 export declare function toPosixRelativePath(input: {
-    readonly path: PosixRelativePath;
+    readonly path: PosixRelativePathOperations;
     readonly from: string;
     readonly to: string;
 }): string;

package/dist/build/output/content-hash.d.ts

@@ -0,0 +1,9 @@
+import { type Schema } from "effect";
+/** BLAKE3 content identity, encoded as lowercase base32 without padding. */
+export declare function toContentHash(source: string | Uint8Array): string;
+/** Encodes an already computed BLAKE3 hash. */
+export declare function encodeContentHash(hash: Uint8Array): string;
+/** The leading 24 characters of the content hash of a client build's canonical identity. */
+export declare function toClientBuildId(identity: Schema.Json): string;
+/** Canonical object ordering; array order carries framework semantics. */
+export declare function encodeCanonicalJson(value: Schema.Json): string;

package/dist/build/output/dist-dir.d.ts

@@ -0,0 +1,34 @@
+import type * as Path from "effect/Path";
+/** The layout of the dist directory and of a build directory, and the stable names of published files. */
+export declare const ARTIFACT_PROTOCOL: {
+    /** Inside the dist directory: the build directory that `vorma build` writes and that the server reads in production. */
+    readonly prodBuildDirName: "prod";
+    /** Inside the dist directory: the build directory that `vorma dev` writes and that the development server reads. */
+    readonly devBuildDirName: "dev";
+    /** Inside the build directory: the build metadata that the server reads at startup. */
+    readonly buildMetadataFileName: "metadata.json";
+    /** Inside the build directory: the published static public assets. */
+    readonly publicDirName: "public";
+    /** Inside the build directory: the lock that a running build or development session holds. */
+    readonly lockDirName: "build.lock";
+    /** Inside the build directory: the directory in which a running build stages its output. */
+    readonly stagingDirName: "staging";
+    readonly publicOutputFileNamePrefix: "vorma_out_";
+    readonly publicModuleFileNamePattern: "vorma_out_[name]-[hash].js";
+    readonly staticPublicAssetFileNamePattern: "vorma_out_[name]-[hash][extname]";
+};
+export type BuildDirPaths = {
+    /** The one directory that the build writes. */
+    readonly buildDir: string;
+    /** The published static public assets. */
+    readonly publicDir: string;
+    /** The build metadata that the server reads. */
+    readonly buildMetadataFilePath: string;
+};
+/** The path operations that the derivation needs; both Effect Path and `node:path` provide them. */
+export type BuildDirPathOperations = Pick<Path.Path, "join">;
+export declare function getBuildDirPaths(input: {
+    readonly path: BuildDirPathOperations;
+    /** The absolute path of the build directory. */
+    readonly buildDir: string;
+}): BuildDirPaths;

package/dist/build/output/output-files.d.ts

@@ -0,0 +1,23 @@
+import { Effect } from "effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+export type GeneratedSourceConflictIssue = {
+    readonly _tag: "GeneratedSourceConflictIssue";
+    readonly filePath: string;
+    readonly msg: string;
+};
+/** Names the temporary directory that `writeOutputFile` writes through, beside the output file. */
+export declare const TEMPORARY_OUTPUT_DIR_PREFIX = "_vorma-write-";
+/**
+ * Atomically replaces generated source that TypeScript and build tools can
+ * read. Existing files must have Vorma's generated-source header. A file that
+ * already holds the source is left untouched, so editors and watchers see no change.
+ */
+export declare function writeOutputFile(input: {
+    readonly filePath: string;
+    readonly source: string;
+}): Effect.Effect<undefined, import("effect/PlatformError").PlatformError | {
+    _tag: "GeneratedSourceConflictIssue";
+    filePath: string;
+    msg: string;
+}, FileSystem.FileSystem | Path.Path>;

package/dist/build/output/output-ownership.d.ts

@@ -0,0 +1,44 @@
+import { Effect, FileSystem, type Scope } from "effect";
+import * as Path from "effect/Path";
+export type OutputOwnershipIssue = {
+    readonly _tag: "OutputOwnershipIssue";
+    readonly dir: string;
+    readonly msg: string;
+    readonly cause?: unknown;
+};
+/** Resolves aliases even when the output directory has not been created. */
+export declare function canonicalizeOutputPath(filePath: string): Effect.Effect<string, OutputOwnershipIssue, FileSystem.FileSystem | Path.Path>;
+/** Checks canonical containment before removing or replacing generated output. */
+export declare function checkOutputPath(input: {
+    readonly filePath: string;
+    readonly rootDir: string;
+}): Effect.Effect<void, OutputOwnershipIssue, FileSystem.FileSystem | Path.Path>;
+/**
+ * A production build's output, staged inside the build directory. Publication
+ * moves the staged files of `public` into the build directory's `public`,
+ * replaces the build metadata in one rename, and then removes the published
+ * files that the staged build does not have. Every file name in `public`
+ * carries a content hash, so a published file with a staged file's name has the
+ * same bytes. The build directory therefore always holds one complete build: the
+ * previous build until the metadata is replaced, and the staged build after
+ * that. A failed build leaves the previous build intact. Closing the scope
+ * removes the staging directory.
+ */
+export type StagedBuildDir = {
+    /** The staging directory, where the build writes. */
+    readonly stagingDir: string;
+    readonly publish: Effect.Effect<void, OutputOwnershipIssue>;
+};
+export declare function createStagedBuildDir(input: {
+    readonly buildDir: string;
+}): Effect.Effect<StagedBuildDir, OutputOwnershipIssue, Scope.Scope | FileSystem.FileSystem | Path.Path>;
+/** The build directory paths of a staged build, inside its staging directory. */
+export declare function getStagedBuildDirPaths(input: {
+    readonly path: Path.Path;
+    readonly staged: StagedBuildDir;
+}): import("./dist-dir.ts").BuildDirPaths;
+/** Owns the build directory until the build or development scope closes. */
+export declare function acquireOutputOwnership(input: {
+    readonly buildDir: string;
+    readonly kind: "build" | "dev";
+}): Effect.Effect<void, OutputOwnershipIssue, Scope.Scope | FileSystem.FileSystem | Path.Path>;

package/dist/build/output/published-file-url.d.ts

@@ -0,0 +1,6 @@
+import type { StaticPublicAssetsServeUrlPathPrefix } from "../config/resolve-config.ts";
+/** The browser URL of a published file: the static public assets base path, then each path segment of the file name, URL-encoded. */
+export declare function toPublishedFileUrl(input: {
+    readonly staticPublicAssetsServeUrlPathPrefix: StaticPublicAssetsServeUrlPathPrefix;
+    readonly fileName: string;
+}): string;

package/dist/build/patterns/nested-route-chains.d.ts

@@ -0,0 +1,12 @@
+import type { CompiledNestedPattern } from "primitives-ts/matcher";
+type NestedRouteNode = {
+    readonly compiledPattern: CompiledNestedPattern;
+};
+/** Builds each unique target's outer-to-inner chain by looking up its compiled path prefixes. */
+export declare function createNestedRouteChains<Node extends NestedRouteNode>(input: {
+    readonly nodes: ReadonlyArray<Node>;
+}): ReadonlyArray<{
+    readonly target: Node;
+    readonly chain: ReadonlyArray<Node>;
+}>;
+export {};

package/dist/build/patterns/pattern-language.d.ts

@@ -0,0 +1,3 @@
+import type * as Matcher from "primitives-ts/matcher";
+/** The view pattern language, with the markers that the client and the server use. */
+export declare const NESTED_PATTERN_LANGUAGE: Matcher.NestedPatternLanguage;

package/dist/build/patterns/route-patterns.d.ts

@@ -0,0 +1,12 @@
+import { type PathWireError } from "@sjcx/vorma-client/unstable";
+import { Result } from "effect";
+import { type CompiledNestedPattern, type PatternCompileError } from "primitives-ts/matcher";
+export type RoutePatternError = PathWireError | PatternCompileError;
+/**
+ * Compiles an authored view route pattern: wire encoding first, then the
+ * nested pattern language. Every view pattern enters the matcher through this
+ * function.
+ */
+export declare function compileViewPattern(pattern: string): Result.Result<CompiledNestedPattern, RoutePatternError>;
+/** A route pattern's compile error as a sentence fragment. */
+export declare function formatRoutePatternError(error: RoutePatternError): string;

package/dist/build/publication/assemble-artifacts.d.ts

@@ -0,0 +1,37 @@
+import { Effect } from "effect";
+import type { ClientBundle } from "../bundling/bundle-client.ts";
+import type { ApplicationGeneration } from "../generation/generate-application.ts";
+import { type BuildMetadata } from "./build-metadata.ts";
+export type ApplicationArtifact = {
+    /** Relative to the published public directory, with decoded filenames. */
+    readonly fileName: string;
+    readonly url: string;
+    readonly hash: string;
+};
+/** The build metadata that the Rust server reads: the browser build's metadata and the hash of the declarations that the build directory is built for. */
+export type ServerBuildMetadata = BuildMetadata & {
+    /** The format of the metadata file, which the server checks. */
+    readonly formatVersion: number;
+    readonly declarationsHash: string;
+    /** The development session's values for the server's Content-Security-Policy sources; absent from production metadata. */
+    readonly devCsp?: {
+        /** Where pages load browser modules, styles, images, and fonts. */
+        readonly moduleServerOrigin: string;
+        /** The module server's WebSocket origin. */
+        readonly webSocketOrigin: string;
+        /** The value of Vite's `html.cspNonce`, which `vorma dev` chooses unless the application sets it. */
+        readonly nonce?: string;
+    };
+};
+export type ApplicationArtifacts = {
+    readonly metadata: ServerBuildMetadata;
+};
+export type ArtifactAssemblyIssue = {
+    readonly _tag: "ArtifactAssemblyIssue";
+    readonly msg: string;
+};
+/** Joins published file metadata and checks paths, collisions, and module projections. */
+export declare function assembleApplicationArtifacts(input: {
+    readonly generation: ApplicationGeneration;
+    readonly client: ClientBundle;
+}): Effect.Effect<ApplicationArtifacts, ArtifactAssemblyIssue>;

package/dist/build/{browser-contracts.d.ts → publication/browser-contracts.d.ts}

@@ -1,5 +1,5 @@
 import type { Schema } from "effect";
-import type { InspectedProjects } from "./inspect-projects.ts";
+import type { InspectedProjects } from "../inspection/inspect-projects.ts";
 /**
  * The static contracts on which browser code and learned routing depend.
  * Source locations, export names, and runtime implementations are not inputs.

package/dist/build/publication/build-metadata.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The format of `metadata.json`. The Rust server checks it when it reads the
+ * file and refuses a file of another format. It changes with any change to the
+ * file's shape that an older reader or writer would misread, and the `vorma`
+ * crate's `BUILD_METADATA_FORMAT_VERSION` has the same value.
+ */
+export declare const BUILD_METADATA_FORMAT_VERSION = 1;
+/** One browser module's build-to-runtime projection. A view module's default export is its view. The metadata leaves out a list that is empty. */
+export type ClientModule = {
+    readonly importUrl: string;
+    readonly depUrls?: ReadonlyArray<string>;
+    readonly cssBundleUrls?: ReadonlyArray<string>;
+    /** The URLs of the static public assets that the module's JavaScript references, not those that only its stylesheets reference. The server preloads the images and fonts among them. */
+    readonly referencedStaticPublicAssetUrls?: ReadonlyArray<string>;
+};
+/** Makes a module's metadata, which leaves out each list that is empty. */
+export declare function createClientModule(input: {
+    readonly importUrl: string;
+    readonly depUrls: ReadonlyArray<string>;
+    readonly cssBundleUrls: ReadonlyArray<string>;
+    readonly referencedStaticPublicAssetUrls: ReadonlyArray<string>;
+}): ClientModule;
+/** Whether the application runs as a production deployment or under the development program. */
+export type RuntimeMode = "prod" | "dev";
+/** Everything one build determines about its own output. The server reads it from the build directory. */
+export type BuildMetadata = {
+    readonly clientBuildId: string;
+    readonly runtimeMode: RuntimeMode;
+    /** The URL path under which the server serves the files of the public output directory, such as `/` or `/static/`. */
+    readonly staticPublicAssetsServeUrlPathPrefix: string;
+    /** The names of exactly the files that the build wrote to the public output directory. The server serves each at the prefix followed by the name, URL-encoded. Every file is content-hashed, so the server serves each as immutable. This inventory stays on the server. */
+    readonly staticPublicAssetFileNames: ReadonlyArray<string>;
+    /** Each static public asset's source key and its published URL path. */
+    readonly staticPublicAssetUrls: Readonly<Record<string, string>>;
+    readonly criticalCss: string;
+    /** The development HTML that Vite's plugins add to the head; absent from production metadata. */
+    readonly devHeadHtml?: string;
+    /** The development HTML that Vite's plugins add to the start of the body; absent from production metadata. */
+    readonly devBodyPrependHtml?: string;
+    /** The development HTML that Vite's plugins add to the end of the body; absent from production metadata. */
+    readonly devBodyHtml?: string;
+    readonly clientEntry: ClientModule;
+    /** Each view's module, by the pattern that the view states. */
+    readonly clientViews: Readonly<Record<string, ClientModule>>;
+};

package/dist/build/publication/publish-artifacts.d.ts

@@ -0,0 +1,17 @@
+import { Effect } from "effect";
+import * as FileSystem from "effect/FileSystem";
+import type { ApplicationSourceLayout } from "../config/source-layout.ts";
+import type { ApplicationGeneration } from "../generation/generate-application.ts";
+import type { ApplicationArtifacts } from "./assemble-artifacts.ts";
+export type ArtifactPublicationIssue = {
+    readonly _tag: "ArtifactPublicationIssue";
+    readonly msg: string;
+    readonly cause: unknown;
+};
+/** Empties the public directory before the build adds its files. */
+export declare function preparePublicOutput(sourceLayout: Pick<ApplicationSourceLayout, "publicDir" | "buildDir">): Effect.Effect<void, ArtifactPublicationIssue | import("../output/output-ownership.ts").OutputOwnershipIssue, FileSystem.FileSystem | import("effect/Path").Path>;
+/** Writes the build metadata, which the server reads, for the completed browser build. */
+export declare function writeBuildMetadata(input: {
+    readonly artifacts: ApplicationArtifacts;
+    readonly generation: ApplicationGeneration;
+}): Effect.Effect<void, ArtifactPublicationIssue, FileSystem.FileSystem>;

package/dist/config-FbabCxBO.js

@@ -0,0 +1,56 @@
+import { Schema } from "effect";
+//#region src/config.ts
+/** The work that a `dev.onChange` rule requests. */
+const DEV_ACTIONS = [
+	"revalidate-client-data",
+	"hard-browser-reload",
+	"restart-server"
+];
+/** An executable followed by its arguments, run without a shell. */
+const Cmd = Schema.TupleWithRest(Schema.Tuple([Schema.NonEmptyString]), [Schema.String]);
+const WrapCmdSchema = Schema.declare((value) => {
+	return typeof value === "function";
+});
+const DevOnChangeRule = Schema.Struct({
+	triggers: Schema.NonEmptyArray(Schema.NonEmptyString),
+	actions: Schema.NonEmptyArray(Schema.Literals(DEV_ACTIONS))
+});
+const VormaConfigSchema = Schema.Struct({
+	core: Schema.Struct({
+		importMetaUrl: Schema.NonEmptyString,
+		distDir: Schema.NonEmptyString,
+		staticPublicAssets: Schema.Struct({
+			srcDir: Schema.NonEmptyString,
+			serveUrlPathPrefix: Schema.String
+		})
+	}),
+	build: Schema.Struct({ serverStartCmd: Cmd }),
+	client: Schema.Struct({
+		tsConfigFile: Schema.NonEmptyString,
+		viteConfigFile: Schema.NonEmptyString,
+		tsGenOutFile: Schema.NonEmptyString,
+		criticalCssFile: Schema.optionalKey(Schema.NonEmptyString),
+		entryFile: Schema.NonEmptyString,
+		viewFilePattern: Schema.NonEmptyString
+	}),
+	dev: Schema.optionalKey(Schema.Struct({
+		server: Schema.Struct({
+			cargoManifestFile: Schema.NonEmptyString,
+			cargoBin: Schema.NonEmptyString,
+			cargoArgs: Schema.optionalKey(Schema.Array(Schema.String)),
+			binArgs: Schema.optionalKey(Schema.Array(Schema.String)),
+			wrapCmdFn: Schema.optionalKey(WrapCmdSchema),
+			preferredPort: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
+				minimum: 1,
+				maximum: 65535
+			})))
+		}),
+		onChange: Schema.optionalKey(Schema.Array(DevOnChangeRule))
+	}))
+});
+/** Types a configuration object where it is written. */
+function defineConfig(config) {
+	return config;
+}
+//#endregion
+export { defineConfig as n, VormaConfigSchema as t };

package/dist/config.d.ts

@@ -0,0 +1,106 @@
+import { Schema } from "effect";
+/** The work that a `dev.onChange` rule requests. */
+declare const DEV_ACTIONS: readonly ["revalidate-client-data", "hard-browser-reload", "restart-server"];
+export type DevAction = (typeof DEV_ACTIONS)[number];
+/** An executable followed by its arguments, run without a shell. */
+declare const Cmd: Schema.TupleWithRest<Schema.Tuple<readonly [Schema.NonEmptyString]>, readonly [Schema.String]>;
+/**
+ * The command that `dev.server.wrapCmdFn` returns for the compiled executable
+ * and the arguments that Vorma would pass to it.
+ */
+type WrapCmd = (input: {
+    readonly executable: string;
+    readonly args: ReadonlyArray<string>;
+}) => typeof Cmd.Type;
+export declare const VormaConfigSchema: Schema.Struct<{
+    readonly core: Schema.Struct<{
+        readonly importMetaUrl: Schema.NonEmptyString;
+        readonly distDir: Schema.NonEmptyString;
+        readonly staticPublicAssets: Schema.Struct<{
+            readonly srcDir: Schema.NonEmptyString;
+            readonly serveUrlPathPrefix: Schema.String;
+        }>;
+    }>;
+    readonly build: Schema.Struct<{
+        readonly serverStartCmd: Schema.TupleWithRest<Schema.Tuple<readonly [Schema.NonEmptyString]>, readonly [Schema.String]>;
+    }>;
+    readonly client: Schema.Struct<{
+        readonly tsConfigFile: Schema.NonEmptyString;
+        readonly viteConfigFile: Schema.NonEmptyString;
+        readonly tsGenOutFile: Schema.NonEmptyString;
+        readonly criticalCssFile: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly entryFile: Schema.NonEmptyString;
+        readonly viewFilePattern: Schema.NonEmptyString;
+    }>;
+    readonly dev: Schema.optionalKey<Schema.Struct<{
+        readonly server: Schema.Struct<{
+            readonly cargoManifestFile: Schema.NonEmptyString;
+            readonly cargoBin: Schema.NonEmptyString;
+            readonly cargoArgs: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly binArgs: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly wrapCmdFn: Schema.optionalKey<Schema.declare<WrapCmd, WrapCmd>>;
+            readonly preferredPort: Schema.optionalKey<Schema.Int>;
+        }>;
+        readonly onChange: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly triggers: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            readonly actions: Schema.NonEmptyArray<Schema.Literals<readonly ["revalidate-client-data", "hard-browser-reload", "restart-server"]>>;
+        }>>>;
+    }>>;
+}>;
+/**
+ * The input of `vorma build` and `vorma dev`, which take the configuration
+ * file as their argument.
+ *
+ * `core.importMetaUrl` is the configuration file's own `import.meta.url`, and
+ * every configured path is relative to that file's directory. `core.distDir`
+ * is the directory that holds Vorma's build output: `vorma build` writes the
+ * production build to `prod` in it, and `vorma dev` writes the development
+ * build to `dev` in it. Vorma owns those two directories and writes nothing
+ * else in `core.distDir`.
+ * `core.staticPublicAssets.srcDir` holds the static public asset sources, and
+ * `serveUrlPathPrefix` is the URL path at which their hashed files are served. The build
+ * skips every entry in `srcDir`, at any depth, that is named `.DS_Store` or
+ * `.env`, or whose name starts with `.env.`, because env files hold secrets by
+ * convention and everything in the public output is public. A skipped file is
+ * not hashed, not published, not a `staticPublicAssets` key, not an input of
+ * the build ID, not watched by `vorma dev`, and not served. It publishes every
+ * other file, dotfiles included.
+ *
+ * `client` names the client project's tsconfig file, the file where the build
+ * writes its generated types, the Vite configuration, the browser entry, the
+ * view files as one glob pattern, and, optionally, the critical CSS file.
+ *
+ * `build.serverStartCmd` is the executable and arguments that `vorma build`
+ * runs without a shell from the configuration directory, with the
+ * declaration-read variable set, so that the application's server writes its
+ * declarations and ends. The application builds that server before it runs
+ * `vorma build`, or names a command that compiles and runs it. `vorma build`
+ * compiles nothing.
+ *
+ * `dev.server` configures the server that `vorma dev` compiles and runs.
+ * `cargoManifestFile` and `cargoBin` name the Cargo target that `vorma dev`
+ * compiles after each server change, and `cargoArgs` are added to that Cargo
+ * command. `vorma dev` reads the declarations by running the compiled
+ * executable with `binArgs`, then runs the same executable with `binArgs` as
+ * the development server, passing the application's port in `PORT`. When
+ * `wrapCmdFn` is set, the development server runs the command that `wrapCmdFn`
+ * returns for the executable and its arguments, for example to run it in a
+ * profiler. `wrapCmdFn` does not wrap the declaration reads.
+ * `preferredPort` is where the search for a free port starts. Each
+ * `dev.onChange` rule pairs file patterns with the actions that a change to a
+ * matching file requests. A pattern is relative to the configuration
+ * directory; a leading `!` excludes the files that it matches from the
+ * patterns before it. The configuration is invalid when a pattern is empty or
+ * when all of a rule's patterns are exclusions. `"restart-server"` rebuilds
+ * and restarts the application's server as a change to a source that Cargo
+ * tracks does, for a file that the server reads at run time and that Cargo
+ * does not track, such as a configuration file or a template.
+ *
+ * `vorma dev` never writes `prod` in `core.distDir`, and `vorma build` never
+ * writes `dev` in it, so a production build stays as it is while `vorma dev`
+ * runs.
+ */
+export type VormaConfig = typeof VormaConfigSchema.Type;
+/** Types a configuration object where it is written. */
+export declare function defineConfig(config: VormaConfig): VormaConfig;
+export {};

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { defineConfig, type DevAction, type VormaConfig } from "./config.ts";

package/dist/index.js

@@ -0,0 +1,2 @@
+import { n as defineConfig } from "./config-FbabCxBO.js";
+export { defineConfig };

package/dist/plugin-api-Btb0teGk.js

@@ -0,0 +1,36 @@
+import { Result } from "effect";
+import { normalize } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/vite/plugin-api.ts
+/** The name by which Vorma's commands find the application's plugin in a resolved Vite configuration. */
+const VORMA_PLUGIN_NAME = "vorma";
+/** Runtime peers that must have one browser identity in every Vite invocation. */
+const CLIENT_SHARED_PACKAGES = [
+	"@vorma/client",
+	"react",
+	"react-dom",
+	"preact",
+	"solid-js"
+];
+/** The path of the configuration file that a configuration's `core.importMetaUrl` identifies. */
+function readConfigFilePath(importMetaUrl) {
+	return Result.try({
+		try: () => fileURLToPath(importMetaUrl),
+		catch: () => {
+			return `core.importMetaUrl must be the configuration file's import.meta.url, got ${JSON.stringify(importMetaUrl)}`;
+		}
+	});
+}
+function findVormaPlugin(plugins) {
+	return plugins.find((plugin) => plugin.name === VORMA_PLUGIN_NAME);
+}
+/** Checks that a resolved Vite configuration's plugin carries the Vorma configuration file that a command loaded. */
+function checkVormaPlugin(input) {
+	const plugin = findVormaPlugin(input.plugins);
+	if (plugin?.api === void 0) return Result.fail("Vorma requires vorma({ config }) from vorma/vite in the configured Vite plugins list.");
+	const { importMetaUrl } = plugin.api.config.core;
+	const pluginConfigFilePath = readConfigFilePath(importMetaUrl);
+	return Result.isSuccess(pluginConfigFilePath) && normalize(pluginConfigFilePath.success) === normalize(input.configFilePath) ? Result.succeed(void 0) : Result.fail(`The Vite configuration's vorma({ config }) received the configuration of ${importMetaUrl}, but Vorma loaded ${input.configFilePath}.`);
+}
+//#endregion
+export { readConfigFilePath as i, VORMA_PLUGIN_NAME as n, checkVormaPlugin as r, CLIENT_SHARED_PACKAGES as t };