ignotum 0.0.0 → 0.0.2

package/dist/cli/bin.mjs

@@ -0,0 +1,1696 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { NodeHttpServer, NodeRuntime, NodeServices, NodeSocket } from "@effect/platform-node";
+import { Array, Brand, Cause, Context, Crypto, DateTime, Effect, Effectable, FiberSet, FileSystem, Function, HashMap, Layer, ManagedRuntime, Option, PartitionedSemaphore, Path, Predicate, PubSub, Ref, Schema, Semaphore, String, Terminal } from "effect";
+import { Argument, CliError, Command, Flag } from "effect/unstable/cli";
+import { fileURLToPath } from "node:url";
+import prefresh from "@prefresh/vite";
+import tailwindcss from "@tailwindcss/vite";
+import { createServer, defaultClientConditions, normalizePath } from "vite";
+import { SqliteClient } from "@effect/sql-sqlite-node";
+import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { SqlClient, SqlSchema } from "effect/unstable/sql";
+import { customAlphabet, nanoid } from "nanoid";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+//#region package.json
+var version = "0.0.2";
+//#endregion
+//#region ../contracts/dist/value-Briqf-Ua.js
+const TransportValueSchema = Schema.suspend(() => Schema.Union([
+	Schema.Null,
+	Schema.Boolean,
+	Schema.Finite,
+	Schema.String,
+	Schema.Date,
+	Schema.Array(TransportValueSchema),
+	Schema.Record(Schema.String, Schema.UndefinedOr(TransportValueSchema))
+]));
+const collectDatePaths = (value, path, paths) => {
+	if (Predicate.isDate(value)) {
+		Schema.decodeSync(Schema.Date)(value);
+		paths.push(path);
+		return;
+	}
+	if (globalThis.Array.isArray(value)) {
+		for (const [index, child] of value.entries()) collectDatePaths(child, [...path, index], paths);
+		return;
+	}
+	if (value === void 0 || Predicate.isNull(value) || Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) return;
+	for (const [key, child] of Object.entries(value)) collectDatePaths(child, [...path, key], paths);
+};
+const datePathsOf = (value) => {
+	const paths = [];
+	collectDatePaths(value, [], paths);
+	return paths;
+};
+const datePathsOfObject = (value) => datePathsOf(Schema.decodeUnknownSync(TransportValueSchema)(value));
+//#endregion
+//#region ../contracts/dist/runtime/sync.js
+const FunctionNamePart = Schema.String.check(Schema.isPattern(/^[A-Za-z_$][A-Za-z0-9_$]*$/));
+const ApiFunctionAddressParts = Schema.TemplateLiteralParser([
+	"api.",
+	FunctionNamePart,
+	".",
+	FunctionNamePart
+]);
+const FunctionAddress = Schema.TemplateLiteral([
+	"api.",
+	FunctionNamePart,
+	".",
+	FunctionNamePart
+]);
+const apiFunctionParts = (address) => {
+	const [, moduleName, , functionName] = Schema.decodeSync(ApiFunctionAddressParts)(address);
+	return {
+		functionName,
+		moduleName
+	};
+};
+const SubscriptionId = Schema.Natural.pipe(Schema.brand("ignotum/sync/SubscriptionId"));
+const RequestId = Schema.Natural.pipe(Schema.brand("ignotum/sync/RequestId"));
+const Subscribe = Schema.Struct({
+	type: Schema.Literal("Subscribe"),
+	id: SubscriptionId,
+	function: FunctionAddress,
+	args: Schema.Json
+});
+const Unsubscribe = Schema.Struct({
+	type: Schema.Literal("Unsubscribe"),
+	id: SubscriptionId
+});
+const Mutate = Schema.Struct({
+	type: Schema.Literal("Mutate"),
+	id: RequestId,
+	function: FunctionAddress,
+	args: Schema.Json
+});
+const ClientMessage = Schema.Union([
+	Subscribe,
+	Unsubscribe,
+	Mutate
+]);
+const QueryOperation = Schema.Struct({
+	type: Schema.Literal("Query"),
+	id: SubscriptionId
+});
+const MutateOperation = Schema.Struct({
+	type: Schema.Literal("Mutate"),
+	id: RequestId
+});
+const Operation = Schema.Union([QueryOperation, MutateOperation]);
+const DatePath = Schema.Array(Schema.Union([Schema.String, Schema.Natural]));
+const DatePaths = Schema.Array(DatePath);
+const WireResult = Schema.Union([Schema.Struct({
+	type: Schema.Literal("Success"),
+	value: Schema.optional(Schema.Json),
+	dates: Schema.optional(DatePaths)
+}), Schema.Struct({
+	type: Schema.Literal("Failure"),
+	error: Schema.Json,
+	dates: Schema.optional(DatePaths)
+})]);
+const QuerySnapshot = Schema.Struct({
+	type: Schema.Literal("QuerySnapshot"),
+	id: SubscriptionId,
+	result: WireResult
+});
+const MutationResult = Schema.Struct({
+	type: Schema.Literal("MutationResult"),
+	id: RequestId,
+	result: WireResult
+});
+const ProtocolErrorCode = Schema.Literals([
+	"DuplicateOperationId",
+	"FunctionUnavailable",
+	"InvalidArguments",
+	"InvalidMessage",
+	"UnknownFunction",
+	"WrongFunctionKind"
+]);
+const ProtocolError = Schema.Struct({
+	type: Schema.Literal("ProtocolError"),
+	operation: Schema.optional(Operation),
+	code: ProtocolErrorCode,
+	message: Schema.String
+});
+const ServerMessage = Schema.Union([
+	QuerySnapshot,
+	MutationResult,
+	ProtocolError
+]);
+const ClientMessageJson = Schema.fromJsonString(ClientMessage);
+const ServerMessageJson = Schema.fromJsonString(ServerMessage);
+//#endregion
+//#region src/cli/codegen.ts
+const generatedHeader = "// Generated by `ignotum codegen`. Do not edit.";
+var SchemaNotFound = class extends Schema.TaggedError()("SchemaNotFound", {
+	message: Schema.String,
+	path: Schema.String
+}) {};
+var InvalidFunctionModuleName = class extends Schema.TaggedError()("InvalidFunctionModuleName", {
+	message: Schema.String,
+	path: Schema.String
+}) {};
+var GeneratedFileConflict = class extends Schema.TaggedError()("GeneratedFileConflict", {
+	message: Schema.String,
+	path: Schema.String
+}) {};
+const isFunctionModuleFile = (fileName) => fileName.endsWith(".ts") && !fileName.endsWith(".test.ts") && !fileName.endsWith(".spec.ts") && fileName !== "index.ts" && fileName !== "schema.ts" && !fileName.startsWith("_");
+const moduleNameFromFile = (filePath, fileName) => {
+	const moduleName = fileName.slice(0, -3);
+	return Schema.decodeEffect(FunctionNamePart)(moduleName).pipe(Effect.mapError(() => InvalidFunctionModuleName.make({
+		message: `Server function file names must be valid TypeScript identifiers. Rename ${fileName}.`,
+		path: filePath
+	})));
+};
+const renderServerBindings = () => `${generatedHeader}
+
+import { bindSchema } from "ignotum/internal/server";
+
+import schema from "../server/schema.js";
+
+export const { mutation, query, values } = bindSchema(schema);
+`;
+const renderTypes = () => `${generatedHeader}
+
+import type {
+  Document as DocumentFor,
+  Id as IdFor,
+  SchemaDefinitionOf,
+} from "ignotum/internal/types";
+
+import type schema from "../server/schema.js";
+
+export type DataModel = SchemaDefinitionOf<typeof schema>;
+export type Doc<TableName extends Extract<keyof DataModel, string>> = DocumentFor<
+  DataModel,
+  TableName
+>;
+export type Id<TableName extends Extract<keyof DataModel, string>> = IdFor<TableName>;
+`;
+const renderApi = (moduleNames) => {
+	const modules = Array.match(moduleNames, {
+		onEmpty: () => "  // No server function modules found.",
+		onNonEmpty: (names) => Array.join(Array.map(names, (moduleName) => `  readonly ${moduleName}: typeof import("../server/${moduleName}.js");`), "\n")
+	});
+	return `${generatedHeader}
+
+import { createApi } from "ignotum/internal/api";
+
+type Modules = {
+${modules}
+};
+
+export const api = createApi<Modules>();
+`;
+};
+const inspectOutput = Effect.fn("Codegen.inspectOutput")(function* (output) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	if (!(yield* fileSystem.exists(output.path))) return "write";
+	const current = yield* fileSystem.readFileString(output.path);
+	if (current === output.content) return "unchanged";
+	if (!current.startsWith(generatedHeader)) return yield* GeneratedFileConflict.make({
+		message: `Refusing to overwrite ${output.path} because it was not created by Ignotum.`,
+		path: output.path
+	});
+	return "write";
+});
+const writeOutput = Effect.fn("Codegen.writeOutput")(function* (output) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const directory = (yield* Path.Path).dirname(output.path);
+	yield* fileSystem.makeDirectory(directory, { recursive: true });
+	yield* Effect.scoped(Effect.gen(function* () {
+		const temporaryPath = yield* fileSystem.makeTempFileScoped({
+			directory,
+			prefix: ".ignotum-",
+			suffix: ".ts"
+		});
+		yield* fileSystem.writeFileString(temporaryPath, output.content);
+		yield* fileSystem.rename(temporaryPath, output.path);
+	}));
+});
+const generate = Effect.fn("Codegen.generate")(function* (projectDirectory) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const serverDirectory = path.join(projectDirectory, "server");
+	const schemaPath = path.join(serverDirectory, "schema.ts");
+	if (!(yield* fileSystem.exists(schemaPath))) return yield* SchemaNotFound.make({
+		message: `No Ignotum schema found at ${schemaPath}.`,
+		path: schemaPath
+	});
+	const entries = yield* fileSystem.readDirectory(serverDirectory);
+	const functionFiles = Array.sort(String.Order)(Array.filter(entries, isFunctionModuleFile));
+	const functionModules = yield* Effect.forEach(functionFiles, (fileName) => moduleNameFromFile(path.join(serverDirectory, fileName), fileName));
+	const outputs = [
+		{
+			content: renderServerBindings(),
+			path: path.join(projectDirectory, "_generated", "server.ts")
+		},
+		{
+			content: renderApi(functionModules),
+			path: path.join(projectDirectory, "_generated", "api.ts")
+		},
+		{
+			content: renderTypes(),
+			path: path.join(projectDirectory, "_generated", "types.ts")
+		}
+	];
+	const inspections = yield* Effect.forEach(outputs, inspectOutput);
+	const inspectedOutputs = Array.zip(outputs, inspections);
+	const outputsToWrite = Array.map(Array.filter(inspectedOutputs, ([, inspection]) => inspection === "write"), ([output]) => output);
+	const unchanged = Array.map(Array.filter(inspectedOutputs, ([, inspection]) => inspection === "unchanged"), ([output]) => output.path);
+	const written = Array.map(outputsToWrite, (output) => output.path);
+	yield* Effect.forEach(outputsToWrite, writeOutput, { discard: true });
+	return {
+		functionModules,
+		unchanged,
+		written
+	};
+});
+//#endregion
+//#region src/dev-runtime/dev-database.ts
+const databaseFileNames = [
+	"state.db",
+	"state.db-shm",
+	"state.db-wal",
+	"state.db-journal"
+];
+const lockFileName = "lock.json";
+const DevDatabaseLockRecord = Schema.Struct({
+	pid: Schema.Int,
+	token: Schema.String
+});
+const DevDatabaseLockRecordJson = Schema.fromJsonString(DevDatabaseLockRecord);
+var DevDatabaseResetFailed = class extends Schema.TaggedError()("DevDatabaseResetFailed", {
+	cause: Schema.Defect(),
+	message: Schema.String,
+	path: Schema.String
+}) {};
+var DevDatabaseInUse = class extends Schema.TaggedError()("DevDatabaseInUse", {
+	message: Schema.String,
+	path: Schema.String,
+	pid: Schema.Int
+}) {};
+var DevDatabaseLockFailed = class extends Schema.TaggedError()("DevDatabaseLockFailed", {
+	cause: Schema.Defect(),
+	message: Schema.String,
+	path: Schema.String
+}) {};
+const devDatabasePath = Effect.fn("DevDatabase.path")(function* (projectDirectory) {
+	return (yield* Path.Path).join(projectDirectory, ".ignotum", "dev", "state.db");
+});
+const processIsRunning = (pid) => {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (cause) {
+		return !(Predicate.hasProperty(cause, "code") && cause.code === "ESRCH");
+	}
+};
+const acquireDevDatabaseLock = Effect.fn("DevDatabase.acquireLock")(function* (projectDirectory) {
+	const crypto = yield* Crypto.Crypto;
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const databasePath = yield* devDatabasePath(projectDirectory);
+	const directory = path.dirname(databasePath);
+	const lockPath = path.join(directory, lockFileName);
+	const record = {
+		pid: process.pid,
+		token: yield* crypto.randomUUIDv4
+	};
+	const encoded = yield* Schema.encodeEffect(DevDatabaseLockRecordJson)(record).pipe(Effect.mapError((cause) => DevDatabaseLockFailed.make({
+		cause,
+		message: `Could not encode the development database lock at ${lockPath}.`,
+		path: lockPath
+	})));
+	yield* fileSystem.makeDirectory(directory, { recursive: true }).pipe(Effect.mapError((cause) => DevDatabaseLockFailed.make({
+		cause,
+		message: `Could not create the development state directory at ${directory}.`,
+		path: lockPath
+	})));
+	const createLock = () => fileSystem.writeFileString(lockPath, encoded, { flag: "wx" }).pipe(Effect.matchEffect({
+		onFailure: (cause) => cause.reason._tag === "AlreadyExists" ? Effect.succeed(false) : DevDatabaseLockFailed.make({
+			cause,
+			message: `Could not create the development database lock at ${lockPath}.`,
+			path: lockPath
+		}),
+		onSuccess: () => Effect.succeed(true)
+	}));
+	const readLock = Effect.fn("DevDatabase.readLock")(function* () {
+		const content = yield* fileSystem.readFileString(lockPath).pipe(Effect.mapError((cause) => DevDatabaseLockFailed.make({
+			cause,
+			message: `Could not read the development database lock at ${lockPath}.`,
+			path: lockPath
+		})));
+		return yield* Schema.decodeEffect(DevDatabaseLockRecordJson)(content).pipe(Effect.mapError((cause) => DevDatabaseLockFailed.make({
+			cause,
+			message: `The development database lock at ${lockPath} is invalid. Remove it and try again.`,
+			path: lockPath
+		})));
+	});
+	const failInUse = (current) => DevDatabaseInUse.make({
+		message: `Another Ignotum development server is using ${databasePath} with process ${current.pid}.`,
+		path: lockPath,
+		pid: current.pid
+	});
+	const acquire = Effect.gen(function* () {
+		if (yield* createLock()) return record;
+		const current = yield* readLock();
+		if (processIsRunning(current.pid)) return yield* failInUse(current);
+		yield* fileSystem.remove(lockPath).pipe(Effect.mapError((cause) => DevDatabaseLockFailed.make({
+			cause,
+			message: `Could not remove the stale development database lock at ${lockPath}.`,
+			path: lockPath
+		})));
+		if (yield* createLock()) return record;
+		return yield* failInUse(yield* readLock());
+	});
+	const release = (owned) => Effect.gen(function* () {
+		if (!(yield* fileSystem.exists(lockPath))) return;
+		const content = yield* fileSystem.readFileString(lockPath);
+		const current = Schema.decodeOption(DevDatabaseLockRecordJson)(content);
+		if (Option.isNone(current) || current.value.token !== owned.token) return;
+		yield* fileSystem.remove(lockPath);
+	}).pipe(Effect.catchCause((cause) => Effect.logWarning(`Could not release the development database lock at ${lockPath}.`).pipe(Effect.annotateLogs({ cause }))));
+	yield* Effect.acquireRelease(acquire, release);
+});
+const resetDevDatabase = Effect.fn("DevDatabase.reset")(function* (projectDirectory) {
+	return yield* Effect.scoped(Effect.gen(function* () {
+		yield* acquireDevDatabaseLock(projectDirectory);
+		const fileSystem = yield* FileSystem.FileSystem;
+		const path = yield* Path.Path;
+		const directory = path.join(projectDirectory, ".ignotum", "dev");
+		const databasePath = yield* devDatabasePath(projectDirectory);
+		let removed = 0;
+		yield* Effect.forEach(databaseFileNames, Effect.fn("DevDatabase.removeFile")(function* (fileName) {
+			const filePath = path.join(directory, fileName);
+			if (!(yield* fileSystem.exists(filePath))) return;
+			yield* fileSystem.remove(filePath);
+			removed += 1;
+		}), { discard: true }).pipe(Effect.mapError((cause) => DevDatabaseResetFailed.make({
+			cause,
+			message: `Could not reset ${databasePath}. Stop the Ignotum dev server and try again.`,
+			path: databasePath
+		})));
+		return {
+			databasePath,
+			removed
+		};
+	}));
+});
+//#endregion
+//#region src/cli/client-plugin.ts
+const clientEntryId = "virtual:ignotum/client-entry";
+const resolvedClientEntryId = `\0${clientEntryId}`;
+const document = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Ignotum</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module">
+      import "${clientEntryId}"
+    <\/script>
+  </body>
+</html>`;
+const clientEntry = `import "preact/debug"
+import { render } from "preact"
+import { jsx } from "preact/jsx-runtime"
+
+import "/styles.css"
+import App from "/App.tsx"
+
+const root = document.getElementById("app")
+
+if (root === null) {
+  throw new Error("Ignotum mount element is missing.")
+}
+
+render(jsx(App, {}), root)
+`;
+const ignotumClientPlugin = () => ({
+	name: "ignotum:client",
+	configureServer: (server) => {
+		server.middlewares.use((request, response, next) => {
+			const acceptsHtml = request.headers.accept?.includes("text/html") === true;
+			const isNavigation = request.method === "GET" || request.method === "HEAD";
+			if (!acceptsHtml || !isNavigation) {
+				next();
+				return;
+			}
+			const requestUrl = request.originalUrl ?? request.url ?? "/";
+			server.transformIndexHtml(requestUrl, document).then((html) => {
+				response.statusCode = 200;
+				response.setHeader("Content-Type", "text/html; charset=utf-8");
+				response.end(request.method === "HEAD" ? void 0 : html);
+			}).catch(next);
+		});
+	},
+	load: (id) => id === resolvedClientEntryId ? clientEntry : void 0,
+	resolveId: (id) => id === clientEntryId ? resolvedClientEntryId : void 0
+});
+//#endregion
+//#region ../runtime/dist/functions.js
+var FunctionRuntime = class extends Context.Service()("@ignotum/runtime/functions/FunctionRuntime") {};
+//#endregion
+//#region ../runtime/dist/sync.js
+var QueryInvalidation = class extends Context.Service()("@ignotum/runtime/sync/QueryInvalidation") {};
+const syncPath = `/_ignotum/sync`;
+const isIgnotumPath = (pathname) => pathname === "/_ignotum" || pathname.startsWith(`/_ignotum/`);
+//#endregion
+//#region ../contracts/dist/runtime/id.js
+const IdAlphabet = "0123456789abcdefghijklmnopqrstuvwxyz";
+const GeneratedId = Schema.String.check(Schema.isPattern(/^[0-9a-z]{24}$/)).pipe(Schema.brand("ignotum/id"));
+//#endregion
+//#region ../contracts/dist/runtime/result.js
+const ResultTypeId = Symbol.for("ignotum/runtime/result/Result");
+const CompletedResultTypeId = Symbol.for("ignotum/runtime/result/Completed");
+const PendingResultTypeId = Symbol.for("ignotum/runtime/result/Pending");
+const ErrorBrand = "ignotum/error";
+Brand.nominal();
+const ErrorValueSchema = Schema.StructWithRest(Schema.Struct({ _tag: Schema.String }), [Schema.Record(Schema.String, Schema.Json)]).pipe(Schema.brand(ErrorBrand));
+var InternalServerErrorCause = class extends Schema.TaggedError()("InternalServerError", { requestId: Schema.String }) {};
+const InternalServerErrorSchema = InternalServerErrorCause.pipe(Schema.brand(ErrorBrand));
+const effectOf = (value) => Predicate.hasProperty(value, ResultTypeId) ? value[ResultTypeId] : Effect.succeed(value);
+function makeResultEffectBase() {
+	const Base = function() {};
+	Base.prototype = Effectable.Prototype({
+		label: "IgnotumResult",
+		evaluate() {
+			return this[ResultTypeId];
+		}
+	});
+	return Base;
+}
+const ResultEffectBase = makeResultEffectBase();
+var ResultOperation = class ResultOperation extends ResultEffectBase {
+	[ResultTypeId];
+	constructor(effect, completed) {
+		super();
+		this[ResultTypeId] = effect;
+		if (completed !== void 0) Object.defineProperty(this, CompletedResultTypeId, { value: completed });
+	}
+	catch(cases) {
+		const effectCases = {};
+		for (const [tag, handler] of Object.entries(cases)) if (Predicate.isFunction(handler)) effectCases[tag] = (failure) => effectOf(handler(failure));
+		const runtimeEffect = this[ResultTypeId];
+		const caught = Effect.catchTags(runtimeEffect, effectCases);
+		return new ResultOperation(caught);
+	}
+};
+var PendingQueryResult = class {
+	[PendingResultTypeId] = PendingResultTypeId;
+};
+const inspectResult = (value) => {
+	if (!Predicate.hasProperty(value, CompletedResultTypeId)) return void 0;
+	return value[CompletedResultTypeId];
+};
+const resultFromEffect = (effect) => new ResultOperation(effect);
+const isFailureResult = (result) => Predicate.hasProperty(result, CompletedResultTypeId) && Predicate.isObject(result[CompletedResultTypeId]) && Predicate.hasProperty(result[CompletedResultTypeId], "type") && result[CompletedResultTypeId].type === "Failure";
+Function.dual(2, (result, matchers) => {
+	if (result instanceof PendingQueryResult) {
+		if (matchers.pending === void 0) throw new Error("A pending Result requires a pending matcher.");
+		return matchers.pending();
+	}
+	if (!Predicate.hasProperty(result, ResultTypeId)) throw new Error("Unknown Result implementation.");
+	const inspected = inspectResult(result);
+	if (inspected?.type === "Success") {
+		const value = inspected.value;
+		return matchers.value(value);
+	}
+	if (!isFailureResult(result)) throw new Error("Unknown or incomplete Result operation.");
+	const error = result[CompletedResultTypeId].error;
+	if (error._tag === "InternalServerError") {
+		const internalError = Schema.decodeUnknownSync(InternalServerErrorSchema)(error);
+		const handler = matchers.internalError;
+		if (handler === void 0) throw internalError;
+		return handler(internalError);
+	}
+	const errorMatcher = matchers.error;
+	if (errorMatcher === void 0) throw new Error(`No matcher was provided for ${error._tag}.`);
+	if (Predicate.isFunction(errorMatcher)) return errorMatcher(error);
+	const handlers = errorMatcher;
+	const handler = Object.hasOwn(handlers, error._tag) ? handlers[error._tag] : void 0;
+	if (handler === void 0) throw new Error(`No matcher was provided for ${error._tag}.`);
+	return handler(error);
+});
+const documentNotFound = (table, id) => Brand.nominal()({
+	_tag: "DocumentNotFound",
+	table,
+	id
+});
+//#endregion
+//#region ../contracts/dist/runtime/schema.js
+const FunctionSchemaTypeId = Symbol.for("ignotum/runtime/schema/FunctionSchema");
+const getFunctionSchema = (value) => value[FunctionSchemaTypeId];
+//#endregion
+//#region ../contracts/dist/schema/index.js
+const SchemaDefinitionTypeId = Symbol.for("ignotum/schema/SchemaDefinition");
+//#endregion
+//#region ../runtime/dist/id.js
+var IdGenerator = class extends Context.Service()("@ignotum/runtime/id/IdGenerator") {};
+//#endregion
+//#region src/dev-runtime/database.ts
+const StoredDocument = Schema.Struct({
+	id: GeneratedId,
+	tableName: Schema.String,
+	createdAt: Schema.Int,
+	updatedAt: Schema.Int,
+	fields: Schema.String
+});
+const DocumentLookup = Schema.Struct({
+	id: Schema.String,
+	tableName: Schema.String
+});
+const TableLookup = Schema.Struct({ tableName: Schema.String });
+var UnknownDatabaseTable = class extends Schema.TaggedError()("UnknownDatabaseTable", {
+	message: Schema.String,
+	tableName: Schema.String
+}) {};
+var DocumentSchemaMismatch = class extends Schema.TaggedError()("DocumentSchemaMismatch", {
+	cause: Schema.Defect(),
+	id: Schema.NullOr(Schema.String),
+	message: Schema.String,
+	operation: Schema.Literals([
+		"collect",
+		"get",
+		"insert",
+		"patch",
+		"replace"
+	]),
+	tableName: Schema.String
+}) {};
+const schemaMismatch = (tableName, id, operation, cause) => DocumentSchemaMismatch.make({
+	cause,
+	id,
+	message: `Document fields for ${tableName} did not match its schema during ${operation}.`,
+	operation,
+	tableName
+});
+const tableFor = Effect.fn("LocalDatabase.tableFor")(function* (schema, tableName) {
+	const table = schema[SchemaDefinitionTypeId][tableName];
+	if (table === void 0) return yield* UnknownDatabaseTable.make({
+		message: `Unknown database table ${tableName}.`,
+		tableName
+	});
+	return table;
+});
+const fieldsCodec = (table) => Schema.fromJsonString(Schema.make(Schema.toCodecJson(table.schema).ast));
+const encodeFields = Effect.fn("LocalDatabase.encodeFields")(function* (schema, tableName, value, operation, id) {
+	const table = yield* tableFor(schema, tableName);
+	return yield* Schema.encodeEffect(fieldsCodec(table), { onExcessProperty: "error" })(value).pipe(Effect.mapError((cause) => schemaMismatch(tableName, id, operation, cause)));
+});
+const decodeFields = Effect.fn("LocalDatabase.decodeFields")(function* (schema, row, operation) {
+	const table = yield* tableFor(schema, row.tableName);
+	return yield* Schema.decodeEffect(fieldsCodec(table), { onExcessProperty: "error" })(row.fields).pipe(Effect.mapError((cause) => schemaMismatch(row.tableName, row.id, operation, cause)));
+});
+const toRuntimeDocument = Effect.fn("LocalDatabase.toRuntimeDocument")(function* (schema, row, operation) {
+	return {
+		...yield* decodeFields(schema, row, operation),
+		id: row.id,
+		createdAt: DateTime.toDate(DateTime.makeUnsafe(row.createdAt)),
+		updatedAt: DateTime.toDate(DateTime.makeUnsafe(row.updatedAt))
+	};
+});
+const nextUpdatedAt = (now, previous) => Math.max(DateTime.toEpochMillis(now), previous + 1);
+var LocalDatabase = class LocalDatabase extends Context.Service()("ignotum/dev-runtime/database/LocalDatabase") {
+	static layer = Layer.effect(LocalDatabase, Effect.gen(function* () {
+		const ids = yield* IdGenerator;
+		const sql = yield* SqlClient.SqlClient;
+		yield* sql`
+        CREATE TABLE IF NOT EXISTS documents (
+          id TEXT PRIMARY KEY NOT NULL
+            CHECK (length(id) = 24 AND id NOT GLOB '*[^0-9a-z]*'),
+          tableName TEXT NOT NULL,
+          createdAt INTEGER NOT NULL,
+          updatedAt INTEGER NOT NULL,
+          fields TEXT NOT NULL CHECK (json_valid(fields))
+        ) STRICT
+      `;
+		yield* sql`
+        CREATE INDEX IF NOT EXISTS documents_table_name_idx
+        ON documents (tableName)
+      `;
+		const findStored = SqlSchema.findOneOption({
+			Request: DocumentLookup,
+			Result: StoredDocument,
+			execute: ({ id, tableName }) => sql`
+          SELECT id, tableName, createdAt, updatedAt, fields
+          FROM documents
+          WHERE id = ${id} AND tableName = ${tableName}
+          LIMIT 1
+        `
+		});
+		const collectStored = SqlSchema.findAll({
+			Request: TableLookup,
+			Result: StoredDocument,
+			execute: ({ tableName }) => sql`
+          SELECT id, tableName, createdAt, updatedAt, fields
+          FROM documents
+          WHERE tableName = ${tableName}
+          ORDER BY createdAt ASC, id ASC
+        `
+		});
+		const find = Effect.fn("LocalDatabase.find")(function* (schema, tableName, id) {
+			yield* tableFor(schema, tableName);
+			const row = yield* findStored({
+				id,
+				tableName
+			});
+			if (Option.isNone(row)) return void 0;
+			return yield* toRuntimeDocument(schema, row.value, "get");
+		});
+		const collect = Effect.fn("LocalDatabase.collect")(function* (schema, tableName) {
+			yield* tableFor(schema, tableName);
+			const rows = yield* collectStored({ tableName });
+			return yield* Effect.forEach(rows, (row) => toRuntimeDocument(schema, row, "collect"));
+		});
+		const insert = Effect.fn("LocalDatabase.insert")(function* (schema, tableName, value) {
+			const fields = yield* encodeFields(schema, tableName, value, "insert", null);
+			const id = yield* ids.generate;
+			const now = DateTime.toEpochMillis(yield* DateTime.now);
+			yield* sql`
+          INSERT INTO documents (id, tableName, createdAt, updatedAt, fields)
+          VALUES (${id}, ${tableName}, ${now}, ${now}, ${fields})
+        `;
+			return id;
+		});
+		const deleteDocument = Effect.fn("LocalDatabase.delete")(function* (schema, tableName, id) {
+			yield* tableFor(schema, tableName);
+			yield* sql`DELETE FROM documents WHERE id = ${id} AND tableName = ${tableName}`;
+		});
+		const patch = Effect.fn("LocalDatabase.patch")(function* (schema, tableName, id, value) {
+			yield* tableFor(schema, tableName);
+			const stored = yield* findStored({
+				id,
+				tableName
+			});
+			if (Option.isNone(stored)) return;
+			const current = yield* decodeFields(schema, stored.value, "patch");
+			const fields = yield* encodeFields(schema, tableName, {
+				...current,
+				...value
+			}, "patch", id);
+			const updatedAt = nextUpdatedAt(yield* DateTime.now, stored.value.updatedAt);
+			yield* sql`
+          UPDATE documents
+          SET fields = ${fields}, updatedAt = ${updatedAt}
+          WHERE id = ${id} AND tableName = ${tableName}
+        `;
+		});
+		const replace = Effect.fn("LocalDatabase.replace")(function* (schema, tableName, id, value) {
+			yield* tableFor(schema, tableName);
+			const stored = yield* findStored({
+				id,
+				tableName
+			});
+			if (Option.isNone(stored)) return;
+			const fields = yield* encodeFields(schema, tableName, value, "replace", id);
+			const updatedAt = nextUpdatedAt(yield* DateTime.now, stored.value.updatedAt);
+			yield* sql`
+          UPDATE documents
+          SET fields = ${fields}, updatedAt = ${updatedAt}
+          WHERE id = ${id} AND tableName = ${tableName}
+        `;
+		});
+		const makeReader = (schema) => Object.freeze({
+			find: (tableName, id) => resultFromEffect(find(schema, tableName, id).pipe(Effect.orDie)),
+			get: (tableName, id) => resultFromEffect(find(schema, tableName, id).pipe(Effect.orDie, Effect.flatMap((document) => document === void 0 ? Effect.fail(documentNotFound(tableName, id)) : Effect.succeed(document)))),
+			query: (tableName) => Object.freeze({ collect: () => resultFromEffect(collect(schema, tableName).pipe(Effect.orDie)) })
+		});
+		const makeWriter = (schema) => {
+			const reader = makeReader(schema);
+			return Object.freeze({
+				...reader,
+				delete: (tableName, id) => resultFromEffect(deleteDocument(schema, tableName, id).pipe(Effect.orDie)),
+				insert: (tableName, value) => resultFromEffect(insert(schema, tableName, value).pipe(Effect.orDie)),
+				patch: (tableName, id, value) => resultFromEffect(patch(schema, tableName, id, value).pipe(Effect.orDie)),
+				replace: (tableName, id, value) => resultFromEffect(replace(schema, tableName, id, value).pipe(Effect.orDie))
+			});
+		};
+		return LocalDatabase.of({
+			queryTransaction: (schema, use) => sql.withTransaction(Effect.gen(function* () {
+				return yield* use(Object.freeze({ db: makeReader(schema) }));
+			})),
+			mutationTransaction: (schema, use) => sql.withTransaction(Effect.gen(function* () {
+				return yield* use(Object.freeze({ db: makeWriter(schema) }));
+			}))
+		});
+	}));
+};
+//#endregion
+//#region src/dev-runtime/id.ts
+const idGeneratorLayer = Layer.sync(IdGenerator, () => {
+	const nanoid = customAlphabet(IdAlphabet, 24);
+	return IdGenerator.of({ generate: Effect.sync(() => GeneratedId.make(nanoid())) });
+});
+//#endregion
+//#region ../contracts/dist/runtime/functions.js
+const FunctionKind = Schema.Literals(["Mutation", "Query"]);
+var UnknownFunction = class extends Schema.TaggedError()("UnknownFunction", {
+	function: FunctionAddress,
+	message: Schema.String
+}) {};
+var WrongFunctionKind = class extends Schema.TaggedError()("WrongFunctionKind", {
+	actual: FunctionKind,
+	expected: FunctionKind,
+	function: FunctionAddress,
+	message: Schema.String
+}) {};
+var InvalidArguments = class extends Schema.TaggedError()("InvalidArguments", {
+	function: FunctionAddress,
+	message: Schema.String
+}) {};
+var FunctionUnavailable = class extends Schema.TaggedError()("FunctionUnavailable", {
+	cause: Schema.Defect(),
+	function: FunctionAddress,
+	message: Schema.String
+}) {};
+//#endregion
+//#region src/dev-runtime/functions.ts
+const inspectRuntimeFunctionDefinition = (value) => {
+	const schema = getFunctionSchema(value);
+	if (schema === void 0 || !Predicate.hasProperty(value, "_tag") || value._tag !== "Mutation" && value._tag !== "Query" || Predicate.hasProperty(value, "args") && value.args !== void 0 && !Predicate.isObject(value.args) || Predicate.hasProperty(value, "returns") && value.returns !== void 0 && !Schema.isSchema(value.returns) || Predicate.hasProperty(value, "errors") && value.errors !== void 0 && !Schema.isSchema(value.errors) || !Predicate.hasProperty(value, "handler") || !Predicate.isFunction(value.handler)) return;
+	if (Predicate.hasProperty(value, "args") && Predicate.isObject(value.args) && !Object.values(value.args).every(Schema.isSchema)) return;
+	return {
+		definition: value,
+		schema
+	};
+};
+var FunctionRegistry = class FunctionRegistry extends Context.Service()("ignotum/dev-runtime/functions/FunctionRegistry") {
+	static layer(server, projectDirectory) {
+		return Layer.effect(FunctionRegistry, Effect.gen(function* () {
+			const path = yield* Path.Path;
+			return FunctionRegistry.of({ resolve: Effect.fn("FunctionRegistry.resolve")(function* (functionAddress, kind, args) {
+				const { functionName, moduleName } = apiFunctionParts(functionAddress);
+				const modulePath = normalizePath(path.join(projectDirectory, "server", `${moduleName}.ts`));
+				const candidate = (yield* Effect.tryPromise({
+					try: () => server.ssrLoadModule(modulePath),
+					catch: (cause) => FunctionUnavailable.make({
+						cause,
+						function: functionAddress,
+						message: `Could not load ${functionAddress}.`
+					})
+				}))[functionName];
+				const inspected = Predicate.isObject(candidate) ? inspectRuntimeFunctionDefinition(candidate) : void 0;
+				if (inspected === void 0) return yield* UnknownFunction.make({
+					function: functionAddress,
+					message: `Unknown server function ${functionAddress}.`
+				});
+				const definition = inspected.definition;
+				if (definition._tag !== kind) return yield* WrongFunctionKind.make({
+					actual: definition._tag,
+					expected: kind,
+					function: functionAddress,
+					message: `${functionAddress} is a ${definition._tag.toLowerCase()}, not a ${kind.toLowerCase()}.`
+				});
+				return {
+					args: yield* Schema.decodeEffect(Schema.toCodecJson(Schema.Struct(definition.args ?? {})))(args).pipe(Effect.mapError(() => InvalidArguments.make({
+						function: functionAddress,
+						message: `Invalid arguments for ${functionAddress}.`
+					}))),
+					definition,
+					schema: inspected.schema
+				};
+			}) });
+		}));
+	}
+};
+var MutationApplicationFailure = class extends Schema.TaggedError()("MutationApplicationFailure", { error: Schema.Json }) {};
+var FunctionExecutor = class FunctionExecutor extends Context.Service()("ignotum/dev-runtime/functions/FunctionExecutor") {
+	static layer = Layer.effect(FunctionExecutor, Effect.gen(function* () {
+		const database = yield* LocalDatabase;
+		const mutationSemaphore = yield* Semaphore.make(1);
+		const encodeSuccess = (definition, value) => definition.returns === void 0 ? Schema.encodeUnknownEffect(Schema.Undefined)(value).pipe(Effect.orDie, Effect.as({ type: "Success" })) : Schema.encodeEffect(Schema.toCodecJson(definition.returns))(value).pipe(Effect.orDie, Effect.map((encoded) => {
+			const result = {
+				type: "Success",
+				value: encoded
+			};
+			const dates = datePathsOf(value);
+			return dates.length === 0 ? result : {
+				...result,
+				dates
+			};
+		}));
+		const encodeFailure = (definition, error) => Schema.encodeEffect(Schema.toCodecJson(definition.errors ?? ErrorValueSchema))(error).pipe(Effect.orDie, Effect.map((encoded) => {
+			const result = {
+				type: "Failure",
+				error: encoded
+			};
+			const dates = datePathsOfObject(error);
+			return dates.length === 0 ? result : {
+				...result,
+				dates
+			};
+		}));
+		return FunctionExecutor.of({ execute: Effect.fn("FunctionExecutor.execute")(function* (functionAddress, kind, resolved) {
+			const invoke = (context) => Effect.gen(() => resolved.definition.handler(context, resolved.args)).pipe(Effect.matchEffect({
+				onFailure: (error) => encodeFailure(resolved.definition, error),
+				onSuccess: (value) => encodeSuccess(resolved.definition, value)
+			}));
+			return yield* (kind === "Query" ? database.queryTransaction(resolved.schema, invoke) : mutationSemaphore.withPermits(1)(database.mutationTransaction(resolved.schema, (context) => invoke(context).pipe(Effect.flatMap((result) => result.type === "Failure" ? Effect.fail(MutationApplicationFailure.make({ error: result.error })) : Effect.succeed(result)))).pipe(Effect.catchTags({ MutationApplicationFailure: ({ error }) => Effect.succeed({
+				type: "Failure",
+				error
+			}) })))).pipe(Effect.orDie, Effect.catchCauseIf((cause) => !Cause.hasInterruptsOnly(cause), (cause) => {
+				const requestId = nanoid();
+				return Effect.logError(`${functionAddress} failed during execution.`).pipe(Effect.annotateLogs({
+					cause,
+					function: functionAddress,
+					requestId
+				}), Effect.as({
+					type: "Failure",
+					error: {
+						_tag: "InternalServerError",
+						requestId
+					}
+				}));
+			}));
+		}) });
+	}));
+};
+/** Adapts the Vite/SQLite development implementation to the shared runtime contract. */
+const functionRuntimeLayer = Layer.effect(FunctionRuntime, Effect.gen(function* () {
+	const registry = yield* FunctionRegistry;
+	const executor = yield* FunctionExecutor;
+	return FunctionRuntime.of({ prepare: Effect.fn("DevFunctionRuntime.prepare")(function* (functionAddress, kind, args) {
+		const resolved = yield* registry.resolve(functionAddress, kind, args);
+		return { execute: executor.execute(functionAddress, kind, resolved) };
+	}) });
+}));
+//#endregion
+//#region src/dev-runtime/sync.ts
+const queryInvalidationLayer = Layer.effect(QueryInvalidation, Effect.gen(function* () {
+	const pubsub = yield* PubSub.unbounded();
+	return QueryInvalidation.of({
+		publish: PubSub.publish(pubsub, void 0),
+		subscribe: PubSub.subscribe(pubsub)
+	});
+}));
+const operationForQuery = (subscriptionId) => ({
+	type: "Query",
+	id: subscriptionId
+});
+const protocolError = (code, message, operation) => {
+	if (operation === void 0) return {
+		type: "ProtocolError",
+		code,
+		message
+	};
+	return {
+		type: "ProtocolError",
+		code,
+		message,
+		operation
+	};
+};
+const runSession = Effect.fn("SyncServer.runSession")(function* (socket) {
+	const runtime = yield* FunctionRuntime;
+	const invalidation = yield* QueryInvalidation;
+	const subscriptions = yield* Ref.make(HashMap.empty());
+	const invocationFibers = yield* FiberSet.make();
+	const querySemaphore = yield* PartitionedSemaphore.make({ permits: 1 });
+	const messageSemaphore = yield* Semaphore.make(1);
+	const writeSemaphore = yield* Semaphore.make(1);
+	const write = yield* socket.writer;
+	const send = Effect.fn("SyncServer.send")(function* (message) {
+		yield* writeSemaphore.withPermits(1)(Schema.encodeEffect(ServerMessageJson)(message).pipe(Effect.flatMap(write)));
+	});
+	const sendResolutionError = (operation, error, deliver = send) => {
+		const code = error._tag;
+		return deliver(protocolError(code, error.message, operation));
+	};
+	const isActive = (subscriptionId, subscription) => Ref.get(subscriptions).pipe(Effect.map((current) => Option.getOrUndefined(HashMap.get(current, subscriptionId)) === subscription));
+	const sendIfActive = Effect.fn("SyncServer.sendIfActive")(function* (subscriptionId, subscription, message) {
+		if (yield* isActive(subscriptionId, subscription)) yield* send(message);
+	});
+	const executeQuery = Effect.fn("SyncServer.executeQuery")(function* (subscriptionId, subscription, previouslyPrepared) {
+		if (!(yield* isActive(subscriptionId, subscription))) return;
+		const operation = operationForQuery(subscriptionId);
+		const deliver = (message) => sendIfActive(subscriptionId, subscription, message);
+		const prepared = previouslyPrepared ?? (yield* runtime.prepare(subscription.function, "Query", subscription.args).pipe(Effect.catchTags({
+			FunctionUnavailable: (error) => sendResolutionError(operation, error, deliver),
+			InvalidArguments: (error) => sendResolutionError(operation, error, deliver),
+			UnknownFunction: (error) => sendResolutionError(operation, error, deliver),
+			WrongFunctionKind: (error) => sendResolutionError(operation, error, deliver)
+		})));
+		if (prepared === void 0) return;
+		yield* deliver({
+			type: "QuerySnapshot",
+			id: subscriptionId,
+			result: yield* prepared.execute
+		});
+	});
+	const scheduleQuery = (subscriptionId, subscription, previouslyPrepared) => querySemaphore.withPermits(subscriptionId, 1)(executeQuery(subscriptionId, subscription, previouslyPrepared)).pipe(Effect.catchCause((cause) => Effect.logError("A query refresh fiber failed.").pipe(Effect.annotateLogs({
+		cause,
+		function: subscription.function,
+		subscriptionId
+	}))), FiberSet.run(invocationFibers), Effect.asVoid);
+	const refresh = Effect.fn("SyncServer.refresh")(function* () {
+		const current = yield* Ref.get(subscriptions);
+		yield* Effect.forEach(HashMap.toEntries(current), ([subscriptionId, subscription]) => scheduleQuery(subscriptionId, subscription));
+	});
+	const invalidations = yield* invalidation.subscribe;
+	yield* PubSub.take(invalidations).pipe(Effect.flatMap(refresh), Effect.forever, Effect.forkScoped);
+	const handleSubscribe = Effect.fn("SyncServer.handleSubscribe")(function* (message) {
+		const operation = operationForQuery(message.id);
+		const current = yield* Ref.get(subscriptions);
+		if (HashMap.has(current, message.id)) {
+			yield* send(protocolError("DuplicateOperationId", `Subscription ${message.id} already exists.`, operation));
+			return;
+		}
+		const prepared = yield* runtime.prepare(message.function, "Query", message.args).pipe(Effect.catchTags({
+			FunctionUnavailable: (error) => sendResolutionError(operation, error),
+			InvalidArguments: (error) => sendResolutionError(operation, error),
+			UnknownFunction: (error) => sendResolutionError(operation, error),
+			WrongFunctionKind: (error) => sendResolutionError(operation, error)
+		}));
+		if (prepared === void 0) return;
+		const subscription = {
+			args: message.args,
+			function: message.function
+		};
+		yield* Ref.update(subscriptions, HashMap.set(message.id, subscription));
+		yield* scheduleQuery(message.id, subscription, prepared);
+	});
+	const handleMutate = Effect.fn("SyncServer.handleMutate")(function* (message) {
+		const operation = {
+			type: "Mutate",
+			id: message.id
+		};
+		const prepared = yield* runtime.prepare(message.function, "Mutation", message.args).pipe(Effect.catchTags({
+			FunctionUnavailable: (error) => sendResolutionError(operation, error),
+			InvalidArguments: (error) => sendResolutionError(operation, error),
+			UnknownFunction: (error) => sendResolutionError(operation, error),
+			WrongFunctionKind: (error) => sendResolutionError(operation, error)
+		}));
+		if (prepared === void 0) return;
+		yield* prepared.execute.pipe(Effect.flatMap((result) => {
+			const response = send({
+				type: "MutationResult",
+				id: message.id,
+				result
+			});
+			return result.type === "Success" ? response.pipe(Effect.ensuring(invalidation.publish)) : response;
+		}), Effect.catchCause((cause) => Effect.logError("A mutation invocation fiber failed.").pipe(Effect.annotateLogs({
+			cause,
+			function: message.function,
+			requestId: message.id
+		}))), FiberSet.run(invocationFibers), Effect.asVoid);
+	});
+	const handleMessage = Effect.fn("SyncServer.handleMessage")(function* (text) {
+		const message = yield* Schema.decodeEffect(ClientMessageJson)(text).pipe(Effect.catch(() => send(protocolError("InvalidMessage", "The WebSocket frame is not valid Ignotum JSON."))));
+		if (message === void 0) return;
+		switch (message.type) {
+			case "Subscribe":
+				yield* handleSubscribe(message);
+				return;
+			case "Unsubscribe":
+				yield* Ref.update(subscriptions, HashMap.remove(message.id));
+				return;
+			case "Mutate":
+				yield* handleMutate(message);
+				return;
+		}
+	});
+	yield* socket.runString((text) => messageSemaphore.withPermits(1)(handleMessage(text)));
+});
+var SyncHandlers = class extends Context.Service()("ignotum/dev-runtime/sync/SyncHandlers") {};
+const makeHandlersLayer = (server, projectDirectory, databasePath) => {
+	const databaseLayer = LocalDatabase.layer.pipe(Layer.provide(Layer.merge(idGeneratorLayer, SqliteClient.layer({ filename: databasePath }))));
+	const executorLayer = FunctionExecutor.layer.pipe(Layer.provide(databaseLayer));
+	const devFunctionRuntimeLayer = functionRuntimeLayer.pipe(Layer.provide(Layer.merge(FunctionRegistry.layer(server, projectDirectory).pipe(Layer.provide(NodeServices.layer)), executorLayer)));
+	const dependencies = Layer.mergeAll(devFunctionRuntimeLayer, queryInvalidationLayer, NodeServices.layer);
+	return Layer.effect(SyncHandlers, Effect.gen(function* () {
+		const invalidation = yield* QueryInvalidation;
+		const fileSystem = yield* FileSystem.FileSystem;
+		const path = yield* Path.Path;
+		const scope = yield* Effect.scope;
+		const reloadSemaphore = yield* Semaphore.make(1);
+		const webSocketServer = yield* Effect.acquireRelease(Effect.sync(() => new NodeSocket.NodeWS.WebSocketServer({
+			maxPayload: 1048576,
+			noServer: true
+		})), (instance) => Effect.callback((resume) => {
+			instance.close(() => resume(Effect.void));
+		}));
+		const httpApp = Effect.gen(function* () {
+			const request = yield* HttpServerRequest.HttpServerRequest;
+			const pathname = new URL(request.url, "http://ignotum.local").pathname;
+			return yield* HttpServerResponse.json(pathname === syncPath ? {
+				code: "UpgradeRequired",
+				message: `Connect to ${syncPath} with WebSocket.`
+			} : {
+				code: "NotFound",
+				message: "Unknown Ignotum API route."
+			}, { status: pathname === syncPath ? 426 : 404 });
+		});
+		const socketApp = Effect.gen(function* () {
+			const socket = yield* (yield* HttpServerRequest.HttpServerRequest).upgrade;
+			yield* runSession(socket);
+			return HttpServerResponse.empty();
+		});
+		const http = yield* NodeHttpServer.makeHandler(httpApp, { scope });
+		const upgrade = yield* NodeHttpServer.makeUpgradeHandler(Effect.succeed(webSocketServer), socketApp, { scope });
+		const serverDirectory = path.join(projectDirectory, "server");
+		const reloadUnsafe = Effect.fn("SyncServer.reload")(function* (file, event) {
+			const relative = path.relative(serverDirectory, file);
+			if (relative.startsWith("..") || path.isAbsolute(relative) || !file.endsWith(".ts")) return;
+			if (event !== "change") yield* generate(projectDirectory).pipe(Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(Path.Path, path));
+			yield* invalidation.publish;
+		});
+		const reload = (file, event) => reloadSemaphore.withPermits(1)(reloadUnsafe(file, event)).pipe(Effect.catchCause((cause) => Effect.logError("Could not reload Ignotum server functions.").pipe(Effect.annotateLogs({
+			cause,
+			event,
+			file
+		}))));
+		return SyncHandlers.of({
+			http,
+			reload,
+			upgrade
+		});
+	})).pipe(Layer.provide(dependencies));
+};
+const isApiPath = (request) => {
+	const pathname = new URL(request.url ?? "/", "http://ignotum.local").pathname;
+	return isIgnotumPath(pathname);
+};
+const isAppOrigin = (host, origin) => {
+	if (host === void 0 || origin === void 0) return false;
+	return Option.match(Schema.decodeOption(Schema.URLFromString)(origin), {
+		onNone: () => false,
+		onSome: (url) => url.origin === origin && url.host === host
+	});
+};
+const rejectUpgrade = (socket) => {
+	socket.write("HTTP/1.1 403 Forbidden\r\nConnection: close\r\nContent-Length: 0\r\n\r\n", () => socket.destroy());
+};
+const ignotumSyncPlugin = Function.dual(2, (projectDirectory, databasePath) => ({
+	name: "ignotum:sync",
+	configureServer: (server) => {
+		if (server.httpServer === null) throw new Error("Ignotum sync requires Vite's Node HTTP server.");
+		const runtime = ManagedRuntime.make(makeHandlersLayer(server, projectDirectory, databasePath));
+		const httpServer = server.httpServer;
+		return runtime.runPromise(SyncHandlers).then((handlers) => {
+			const onUpgrade = (request, socket, head) => {
+				if (new URL(request.url ?? "/", "http://ignotum.local").pathname !== syncPath) return;
+				if (!isAppOrigin(request.headers.host, request.headers.origin)) {
+					rejectUpgrade(socket);
+					return;
+				}
+				handlers.upgrade(request, socket, head);
+			};
+			const onAdd = (file) => runtime.runFork(handlers.reload(file, "add"));
+			const onChange = (file) => runtime.runFork(handlers.reload(file, "change"));
+			const onUnlink = (file) => runtime.runFork(handlers.reload(file, "unlink"));
+			const cleanup = () => {
+				httpServer.off("upgrade", onUpgrade);
+				server.watcher.off("add", onAdd);
+				server.watcher.off("change", onChange);
+				server.watcher.off("unlink", onUnlink);
+				runtime.dispose();
+			};
+			httpServer.on("upgrade", onUpgrade);
+			httpServer.once("close", cleanup);
+			server.watcher.on("add", onAdd);
+			server.watcher.on("change", onChange);
+			server.watcher.on("unlink", onUnlink);
+			server.middlewares.use((request, response, next) => {
+				if (!isApiPath(request)) {
+					next();
+					return;
+				}
+				handlers.http(request, response);
+			});
+		}, (error) => {
+			runtime.dispose();
+			throw error;
+		});
+	}
+}));
+//#endregion
+//#region src/cli/dev.ts
+const requiredClientFiles = ["App.tsx", "styles.css"];
+const preactSpecifiers = [
+	"preact/jsx-dev-runtime",
+	"preact/jsx-runtime",
+	"preact/devtools",
+	"preact/debug",
+	"preact/hooks",
+	"preact"
+];
+const prefreshSpecifiers = ["@prefresh/core", "@prefresh/utils"];
+var ClientFileNotFound = class extends Schema.TaggedError()("ClientFileNotFound", {
+	message: Schema.String,
+	path: Schema.String
+}) {};
+var ClientRuntimeResolutionFailed = class extends Schema.TaggedError()("ClientRuntimeResolutionFailed", {
+	cause: Schema.Defect(),
+	message: Schema.String
+}) {};
+var ViteStartupFailed = class extends Schema.TaggedError()("ViteStartupFailed", {
+	cause: Schema.Defect(),
+	message: Schema.String
+}) {};
+const validateClientFiles = Effect.fn("Dev.validateClientFiles")(function* (projectDirectory) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const clientDirectory = path.join(projectDirectory, "client");
+	yield* Effect.forEach(requiredClientFiles, Effect.fn("Dev.validateClientFile")(function* (fileName) {
+		const filePath = path.join(clientDirectory, fileName);
+		if (!(yield* fileSystem.exists(filePath))) return yield* ClientFileNotFound.make({
+			message: `Required client file not found: ${filePath}`,
+			path: filePath
+		});
+	}), { discard: true });
+});
+const resolveClientAliases = Effect.fn("Dev.resolveClientAliases")(function* () {
+	return yield* Effect.try({
+		try: () => {
+			const prefreshRequire = createRequire(import.meta.resolve("@prefresh/vite"));
+			return [
+				{
+					find: /^tailwindcss$/,
+					replacement: normalizePath(fileURLToPath(import.meta.resolve("tailwindcss/index.css")))
+				},
+				...preactSpecifiers.map((specifier) => ({
+					find: specifier,
+					replacement: normalizePath(fileURLToPath(import.meta.resolve(specifier)))
+				})),
+				...prefreshSpecifiers.map((specifier) => ({
+					find: specifier,
+					replacement: normalizePath(prefreshRequire.resolve(specifier))
+				}))
+			];
+		},
+		catch: (cause) => ClientRuntimeResolutionFailed.make({
+			cause,
+			message: "Ignotum could not resolve its client runtime."
+		})
+	});
+});
+const acquireViteServer = Effect.fn("Dev.acquireViteServer")(function* (options) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const aliases = yield* resolveClientAliases();
+	const clientDirectory = path.join(options.projectDirectory, "client");
+	const databasePath = yield* devDatabasePath(options.projectDirectory);
+	const stateDirectory = path.dirname(databasePath);
+	const sourceClientEntry = fileURLToPath(new URL("../../src/client/index.ts", import.meta.url));
+	const sourceContractsEntry = fileURLToPath(new URL("../../../contracts/src/schema/index.ts", import.meta.url));
+	const hasSourceClient = yield* fileSystem.exists(sourceClientEntry);
+	const hasSourceContracts = yield* fileSystem.exists(sourceContractsEntry);
+	const hasWorkspaceSourceExports = hasSourceClient && hasSourceContracts;
+	yield* fileSystem.makeDirectory(stateDirectory, { recursive: true });
+	return yield* Effect.acquireRelease(Effect.tryPromise({
+		try: () => prefresh().then((prefreshPlugin) => createServer({
+			appType: "spa",
+			configFile: false,
+			mode: "development",
+			root: clientDirectory,
+			plugins: [
+				ignotumSyncPlugin(options.projectDirectory, databasePath),
+				ignotumClientPlugin(),
+				prefreshPlugin,
+				tailwindcss()
+			],
+			oxc: { jsx: {
+				importSource: "ignotum/client",
+				runtime: "automatic"
+			} },
+			resolve: {
+				alias: aliases,
+				conditions: [...hasWorkspaceSourceExports ? ["@ignotum/source"] : [], ...defaultClientConditions],
+				dedupe: ["preact"],
+				tsconfigPaths: true
+			},
+			server: {
+				forwardConsole: {
+					logLevels: ["warn", "error"],
+					unhandledErrors: true
+				},
+				host: options.host,
+				open: options.open,
+				port: options.port,
+				strictPort: true
+			}
+		})),
+		catch: (cause) => ViteStartupFailed.make({
+			cause,
+			message: "Ignotum could not create the Vite development server."
+		})
+	}), (server) => Effect.promise(() => server.close()));
+});
+const listen = Effect.fn("Dev.listen")(function* (server) {
+	yield* Effect.tryPromise({
+		try: () => server.listen(),
+		catch: (cause) => ViteStartupFailed.make({
+			cause,
+			message: "Ignotum could not start the Vite development server."
+		})
+	});
+});
+const dev$1 = Effect.fn("Dev.run")(function* (options) {
+	yield* validateClientFiles(options.projectDirectory);
+	yield* generate(options.projectDirectory);
+	return yield* Effect.scoped(Effect.gen(function* () {
+		yield* acquireDevDatabaseLock(options.projectDirectory);
+		const server = yield* acquireViteServer(options);
+		yield* listen(server);
+		yield* Effect.sync(() => {
+			server.printUrls();
+			server.bindCLIShortcuts({ print: true });
+		});
+		return yield* Effect.never;
+	}));
+});
+const agentProjectFiles = [
+	{
+		content: "# AGENTS.md\n\nThis is an Ignotum app. Before changing it, read `.agents/skills/ignotum/SKILL.md`.\n\nThe skill explains how to inspect the project, which bundled reference to read, and how to check\nyour changes.\n",
+		path: "AGENTS.md"
+	},
+	{
+		content: "---\nname: ignotum\ndescription: Build and modify an Ignotum app. Use when working on its schema, server functions, generated API, client UI, or local development workflow.\n---\n\n# Working on an Ignotum app\n\nAn Ignotum app defines a database schema, server functions, and a JSX client. Ignotum supplies the\ndatabase runtime, generated bindings, realtime query updates, Vite dev server, JSX runtime, and\nTailwind setup.\n\nThe current release supports local development. Do not assume that authentication, files, actions,\nworkflows, scheduled jobs, or production deployment APIs exist.\n\n## Start with the app\n\nInspect `server/schema.ts`, the function modules in `server`, the files in `client`, `package.json`,\nand `tsconfig.json` before changing code.\n\nTreat `_generated` as compiler output. Read it when you need to understand an inferred type, but do\nnot edit it. After code changes, regenerate the bindings and run the typechecker:\n\n```sh\nnpx ignotum codegen\nnpx tsc --noEmit\n```\n\nFor normal Ignotum app work, do not add an HTML file, Vite configuration, Tailwind configuration,\nAPI routes, or direct database setup.\n\n## Read the relevant reference\n\nThe bundled references are the Ignotum user guides. Read only the guides needed for the task:\n\n- For project creation and installation, read [getting started](references/getting-started.md) or\n  [manual setup](references/manual-setup.md).\n- For tables, fields, IDs, and generated document types, read\n  [schema syntax](references/schema.md).\n- For validators and their TypeScript types, read [values](references/values.md).\n- For queries, mutations, database access, Results, and application errors, read\n  [server functions](references/server-functions.md).\n- For hooks, query state, mutations, JSX, and Tailwind, read [client](references/client.md).\n- For development commands, code generation, flags, and local data, read\n  [dev server](references/dev-server.md).\n- For the complete guide list, read the [documentation index](references/index.md).\n\n## Rules that cross guide boundaries\n\n- Define tables in `server/schema.ts`.\n- Put queries and mutations in TypeScript files directly inside `server`.\n- Import server builders from `@/_generated/server.js` and client references from\n  `@/_generated/api.js`. Keep the `.js` suffix.\n- Put code used by both the client and server in `shared` and import it through `@/shared`.\n- Never edit `_generated`.\n- Use JSX and hooks from `ignotum/client`, not React or Preact packages directly.\n- Keep the app inside Ignotum's current model unless the user explicitly asks to move beyond it.\n",
+		path: ".agents/skills/ignotum/SKILL.md"
+	},
+	...[
+		["client.md", "# Client\n\nIgnotum apps use JSX, hooks from `ignotum/client`, and Tailwind CSS. Import server function\nreferences from `@/_generated/api.js`:\n\n```tsx\nimport { Query, Result, useMutation, useQuery } from \"ignotum/client\";\n\nimport { api } from \"@/_generated/api.js\";\n```\n\n## Tailwind CSS\n\nEvery app has `client/styles.css` with the Tailwind import:\n\n```css\n@import \"tailwindcss\";\n```\n\nStyle JSX with Tailwind utility classes. Use the JSX `class` attribute:\n\n```tsx\nexport default function App() {\n  return (\n    <main class=\"mx-auto max-w-xl px-6 py-16\">\n      <h1 class=\"text-2xl font-semibold text-zinc-950\">Todos</h1>\n    </main>\n  );\n}\n```\n\nThe dev server loads `styles.css` and configures Tailwind. The app does not need a Tailwind\nconfiguration file.\n\n## Run a query\n\n`useQuery` takes a generated query reference. Pass the typed arguments when the query declares\nthem:\n\n```tsx\nconst todos = useQuery(api.todos.list);\nconst todo = useQuery(api.todos.get, { id });\nconst selectedTodo = useQuery(api.todos.get, id === undefined ? Query.skip : { id });\n```\n\n`Query.skip` keeps a query pending without opening a subscription. Use it when the arguments are\nnot available yet.\n\nThe first value is pending. Match every state with `Result.match`:\n\n```tsx\nreturn Result.match(todos, {\n  pending: () => <p class=\"text-zinc-500\">Loading...</p>,\n  value: (items) => (\n    <ul>\n      {items.map((todo) => (\n        <li key={todo.id}>{todo.text}</li>\n      ))}\n    </ul>\n  ),\n});\n```\n\nIgnotum keeps an active query up to date. A successful mutation refreshes subscribed queries in\nevery open client.\n\n## Run a mutation\n\n`useMutation` takes a generated mutation reference and returns a function:\n\n```tsx\nconst createTodo = useMutation(api.todos.create);\n\nvoid createTodo({ text }).then(\n  Result.match({\n    value: (id) => console.log(id),\n    error: {\n      InvalidTodoText: ({ text }) => console.log(`Invalid text: ${text}`),\n      TodoLimitReached: ({ limit }) => console.log(`The limit is ${limit}`),\n    },\n    internalError: ({ requestId }) => console.log(`Request ${requestId} failed.`),\n  }),\n);\n```\n\nAn argument-free mutation returns a zero-argument function:\n\n```tsx\nconst clearTodos = useMutation(api.todos.clear);\nvoid clearTodos();\n```\n\nThe client `Result` API only inspects completed server responses. Server-only operations such as\n`Result.fail`, `Result.succeed`, `Result.try`, `yield*`, and `.catch()` are not available here.\n\nApplication errors are handled by `error`, either with one function or an exhaustive map keyed by\n`_tag`. An `InternalServerError` contains a request ID and is thrown when `Result.match` has no\n`internalError` handler. During rendering, it reaches the nearest UI error boundary. A mutation can\nhandle it locally with `internalError`, as above. Connection and protocol failures reject mutation\npromises; query connection failures go to the nearest UI error boundary.\n"],
+		["dev-server.md", "# Dev server\n\nRun the dev server from the project root:\n\n```sh\nnpx ignotum dev\n```\n\nIt expects these files:\n\n```text\nclient/App.tsx\nclient/styles.css\nserver/schema.ts\n```\n\nThe dev server generates the client and server bindings, mounts the default export from\n`client/App.tsx`, loads Tailwind from `client/styles.css`, and serves the app at\n<http://127.0.0.1:3210>. It reloads client and server changes and updates active queries after\nserver changes and successful mutations.\n\nYou do not need an HTML file, Vite configuration, or Tailwind configuration.\n\n## Flags\n\nUse flags to change the address or open the browser:\n\n```sh\nnpx ignotum dev --host 0.0.0.0 --port 3000 --open\n```\n\nThe defaults are host `127.0.0.1`, port `3210`, and no automatic browser opening.\n\n## Code generation\n\nThe dev server runs code generation when it starts. It updates generated files when you add or\nremove a server function file.\n\nRun code generation before typechecking without the dev server:\n\n```sh\nnpx ignotum codegen\nnpx tsc --noEmit\n```\n\nIgnotum creates:\n\n- `_generated/server.ts` with schema-bound `query`, `mutation`, and `values` exports;\n- `_generated/api.ts` with client references such as `api.todos.list`;\n- `_generated/types.ts` with `DataModel`, `Doc`, and `Id`.\n\nDo not edit generated files.\n\n## Local data\n\nData persists between dev-server restarts. Stop the server and reset that data with:\n\n```sh\nnpx ignotum dev db reset\n```\n"],
+		["getting-started.md", "# Getting started\n\nIgnotum requires Node.js 22.18 or newer.\n\nCreate an app:\n\n```sh\nnpx ignotum new my-app\ncd my-app\nnpx ignotum dev\n```\n\nOpen <http://127.0.0.1:3210>. The generated app is a small counter with a schema, a query, a\nmutation, and a JSX client.\n\n`ignotum new` installs dependencies with pnpm when it is available. It falls back to npm only when\npnpm is not installed. It generates `_generated`, initializes a Git repository, and creates an\n`Init` commit containing the generated files after the rest of the setup finishes.\n\nPass `.` to create the app in the current directory. The directory must be empty:\n\n```sh\nnpx ignotum new .\n```\n\nUse `--no-git` to skip Git or `--no-install` to skip dependency installation. You can install the\ndependencies later with the same pnpm and npm fallback behavior:\n\n```sh\nnpx ignotum install\n```\n\nRead [schema syntax](schema.md), [server functions](server-functions.md), and the\n[client guide](client.md) to build the app. The [manual setup](manual-setup.md) recreates the counter\napp without `ignotum new`.\n"],
+		["index.md", "# Ignotum\n\nAn Ignotum app has a schema, server functions, and a client. Ignotum is opinionated about the\nclient tooling. Every app uses JSX, hooks from `ignotum/client`, and Tailwind CSS.\n\nThe current release supports local development.\n\n- [Getting started](getting-started.md) creates and runs a counter app with `ignotum new`.\n- [Manual setup](manual-setup.md) recreates the generated counter app by hand.\n- [Schema syntax](schema.md) covers tables, fields, IDs, and generated document types.\n- [Values](values.md) lists every value validator and its TypeScript type.\n- [Server functions](server-functions.md) covers queries, mutations, database access, and errors.\n- [Client](client.md) covers queries, mutations, results, and Tailwind styling.\n- [Dev server](dev-server.md) covers local development, code generation, flags, and data reset.\n"],
+		["manual-setup.md", "# Manual setup\n\nIgnotum requires Node.js 22.18 or newer. This guide recreates the counter app from `ignotum new`\nwithout running the project generator. It uses pnpm to install dependencies.\n\nCreate the project directory:\n\n```sh\nmkdir my-ignotum-app\ncd my-ignotum-app\n```\n\nCreate this structure:\n\n```text\nmy-ignotum-app/\n  client/\n    App.tsx\n    styles.css\n  server/\n    counter.ts\n    schema.ts\n  shared/\n    utils.ts\n  package.json\n  tsconfig.json\n```\n\n## Configure the package\n\nAdd `package.json`:\n\n```json\n{\n  \"name\": \"my-ignotum-app\",\n  \"private\": true,\n  \"version\": \"0.0.0\",\n  \"type\": \"module\",\n  \"scripts\": {\n    \"typecheck\": \"ignotum codegen && tsc --noEmit\"\n  },\n  \"dependencies\": {\n    \"ignotum\": \"latest\"\n  },\n  \"devDependencies\": {\n    \"typescript\": \"^7.0.2\"\n  },\n  \"engines\": {\n    \"node\": \">=22.18.0\"\n  }\n}\n```\n\nInstall the dependencies:\n\n```sh\npnpm install\n```\n\n## Configure TypeScript\n\nAdd `tsconfig.json`:\n\n```json\n{\n  \"compilerOptions\": {\n    \"target\": \"ES2023\",\n    \"lib\": [\"ES2023\", \"DOM\", \"DOM.Iterable\"],\n    \"module\": \"NodeNext\",\n    \"moduleResolution\": \"NodeNext\",\n    \"jsx\": \"react-jsx\",\n    \"jsxImportSource\": \"ignotum/client\",\n    \"strict\": true,\n    \"noEmit\": true,\n    \"skipLibCheck\": true,\n    \"paths\": {\n      \"@/*\": [\"./*\"]\n    }\n  },\n  \"include\": [\"_generated\", \"client\", \"server\", \"shared\"]\n}\n```\n\n## Add shared code\n\nAdd `shared/utils.ts`:\n\n```ts\nexport const counterIncrement = 1;\n```\n\nBoth the client and server can import files in `shared` through `@/shared`.\n\n## Define the schema\n\nAdd `server/schema.ts`:\n\n```ts\nimport { defineSchema } from \"ignotum/server\";\n\nexport default defineSchema(({ table, values }) => ({\n  counters: table({\n    value: values.number(),\n  }),\n}));\n```\n\n## Add the server functions\n\nAdd `server/counter.ts`:\n\n```ts\nimport { mutation, query, values } from \"@/_generated/server.js\";\nimport { counterIncrement } from \"@/shared/utils.js\";\n\nexport const get = query({\n  returns: values.number(),\n\n  handler: function* (ctx) {\n    const counters = yield* ctx.db.query(\"counters\").collect();\n    return counters[0]?.value ?? 0;\n  },\n});\n\nexport const increment = mutation({\n  returns: values.number(),\n\n  handler: function* (ctx) {\n    const counters = yield* ctx.db.query(\"counters\").collect();\n    const counter = counters[0];\n    const value = (counter?.value ?? 0) + counterIncrement;\n\n    if (counter === undefined) {\n      yield* ctx.db.insert(\"counters\", { value });\n    } else {\n      yield* ctx.db.patch(\"counters\", counter.id, { value });\n    }\n\n    return value;\n  },\n});\n```\n\nKeep the `.js` suffix on imports from `@/_generated`, even though the generated files use\nTypeScript.\n\n## Add the client\n\nAdd `client/styles.css`:\n\n```css\n@import \"tailwindcss\";\n```\n\nAdd `client/App.tsx`:\n\n```tsx\nimport { Result, useMutation, useQuery } from \"ignotum/client\";\n\nimport { api } from \"@/_generated/api.js\";\nimport { counterIncrement } from \"@/shared/utils.js\";\n\nexport default function App() {\n  const count = useQuery(api.counter.get);\n  const increment = useMutation(api.counter.increment);\n\n  return (\n    <main class=\"mx-auto max-w-sm px-6 py-20 text-center\">\n      <h1 class=\"text-2xl font-semibold\">Counter</h1>\n      {Result.match(count, {\n        pending: () => <p class=\"mt-6\">Loading...</p>,\n        value: (value) => (\n          <>\n            <p class=\"my-6 text-5xl tabular-nums\">{value}</p>\n            <button\n              class=\"rounded bg-zinc-900 px-4 py-2 text-white\"\n              type=\"button\"\n              onClick={() => void increment()}\n            >\n              Increment by {counterIncrement}\n            </button>\n          </>\n        ),\n      })}\n    </main>\n  );\n}\n```\n\nIgnotum loads Tailwind from `client/styles.css`. You do not need an HTML file, Vite configuration,\nor Tailwind configuration.\n\n## Run the app\n\nStart the dev server:\n\n```sh\nnpx ignotum dev\n```\n\nOpen <http://127.0.0.1:3210>. Ignotum creates `_generated` before starting the app.\n\nRead [schema syntax](schema.md), [server functions](server-functions.md), and the\n[client guide](client.md) to continue building the app.\n"],
+		["schema.md", "# Schema syntax\n\nDefine the data model in `server/schema.ts`. The keys returned from `defineSchema` are table\nnames, and each `table` call defines that table's fields:\n\n```ts\nimport { defineSchema } from \"ignotum/server\";\n\nexport default defineSchema(({ table, values }) => ({\n  users: table({\n    name: values.string(),\n  }),\n  todos: table({\n    text: values.string(),\n    completed: values.boolean(),\n    ownerId: values.optional(values.id(\"users\")),\n  }),\n}));\n```\n\n## Field values\n\nRead [values](values.md) for the complete validator list and the TypeScript type produced by each\none. `values.id` only accepts a table declared in the same schema. Arrays and objects can be nested,\nand their contents can use any value validator.\n\n## System fields\n\nIgnotum adds three fields to every stored document:\n\n| Field       | Type                      |\n| ----------- | ------------------------- |\n| `id`        | The ID type for its table |\n| `createdAt` | `Date`                    |\n| `updatedAt` | `Date`                    |\n\nDo not declare these fields in a table. Do not pass them to `insert`, `patch`, or `replace`.\n\n## Generated types\n\n`_generated/types.ts` exports the data model, document, and ID types:\n\n```ts\nimport type { DataModel, Doc, Id } from \"@/_generated/types.js\";\n\ntype Todo = Doc<\"todos\">;\ntype TodoId = Id<\"todos\">;\n```\n\n`Doc<\"todos\">` includes the fields from the `todos` table and its three system fields. An\n`Id<\"todos\">` cannot be passed where an `Id<\"users\">` is required.\n"],
+		["server-functions.md", "# Server functions\n\nPut queries and mutations in `.ts` files directly inside `server`. The file name becomes the API\nmodule, and each exported function keeps its export name:\n\n```text\nserver/todos.ts -> api.todos.list\nserver/users.ts -> api.users.get\n```\n\nIgnotum ignores `schema.ts`, `index.ts`, test files, and names beginning with `_`.\n\nImport schema-bound builders from the generated server file. Import `Result` only when the module\nintroduces or catches typed errors:\n\n```ts\nimport { Result } from \"ignotum/server\";\n\nimport { mutation, query, values } from \"@/_generated/server.js\";\n```\n\nKeep the `.js` suffix on generated imports.\n\n## Define a function\n\nA function has optional argument, return, and public error schemas, plus a generator handler:\n\n```ts\nexport const getTitle = query({\n  args: {\n    id: values.id(\"todos\"),\n  },\n  returns: values.string(),\n\n  handler: function* (ctx, args) {\n    const todo = yield* ctx.db.get(\"todos\", args.id);\n    return todo.text;\n  },\n});\n```\n\nOmit `args` when the function takes no arguments. Omit `returns` when it returns nothing. An\nomitted `returns` only permits a `void` handler; Ignotum never infers an unchecked return schema.\n`yield*` waits for an Ignotum operation and propagates its typed application errors. Return\nsuccessful values with ordinary `return`.\n\nIgnotum validates arguments before running the handler. It also validates returned values and\npublic application errors before sending them to a client.\n\nAn argument-free query and a mutation with no return value can stay small:\n\n```ts\nexport const list = query({\n  returns: values.array(Todo),\n\n  handler: function* (ctx) {\n    return yield* ctx.db.query(\"todos\").collect();\n  },\n});\n\nexport const remove = mutation({\n  args: { id: values.id(\"todos\") },\n\n  handler: function* (ctx, args) {\n    yield* ctx.db.delete(\"todos\", args.id);\n  },\n});\n```\n\nCall an argument-free query as `useQuery(api.todos.list)`. An argument-free mutation returns a\nzero-argument function:\n\n```ts\nconst clear = useMutation(api.todos.clear);\nvoid clear();\n```\n\n## Database reads\n\nUse `find` when a missing document is a normal result:\n\n```ts\nconst todo = yield * ctx.db.find(\"todos\", args.id);\n// Todo | undefined\n```\n\nUse `get` when the document should exist:\n\n```ts\nconst todo = yield * ctx.db.get(\"todos\", args.id);\n// Todo\n```\n\nA missing `get` fails with a typed `DocumentNotFound` value containing `table` and `id`. Collect a\nwhole table through a query:\n\n```ts\nconst todos = yield * ctx.db.query(\"todos\").collect();\n```\n\nQuery handlers only receive read methods.\n\n## Database writes\n\nMutation handlers receive the read methods and these writes:\n\n```ts\nconst id =\n  yield *\n  ctx.db.insert(\"todos\", {\n    text: \"Learn Ignotum\",\n    completed: false,\n  });\n\nyield * ctx.db.patch(\"todos\", id, { completed: true });\n\nyield *\n  ctx.db.replace(\"todos\", id, {\n    text: \"Build an app\",\n    completed: false,\n  });\n\nyield * ctx.db.delete(\"todos\", id);\n```\n\n`patch` changes only supplied fields. `replace` requires every non-optional table field. Ignotum\nrolls back a mutation when its handler fails with a typed application error or encounters an\ninternal failure.\n\n## Application errors\n\nDefine an application error with `values.error`. Its name becomes `_tag`:\n\n```ts\nconst TodoNotFound = values.error(\"TodoNotFound\", {\n  id: values.id(\"todos\"),\n});\n```\n\n`Result.fail` deliberately stops the operation with a typed error:\n\n```ts\nyield * Result.fail(TodoNotFound({ id: args.id }));\n```\n\nThe `errors` field is optional. If omitted, Ignotum infers the handler's remaining application\nerrors. If supplied, it is the public contract and the handler must conform to it:\n\n```ts\nexport const toggle = mutation({\n  args: {\n    id: values.id(\"todos\"),\n  },\n  returns: values.boolean(),\n  errors: TodoNotFound,\n\n  handler: function* (ctx, args) {\n    const todo = yield* ctx.db.get(\"todos\", args.id).catch({\n      DocumentNotFound: (error) => Result.fail(TodoNotFound({ id: error.id })),\n    });\n\n    const completed = !todo.completed;\n    yield* ctx.db.patch(\"todos\", args.id, { completed });\n    return completed;\n  },\n});\n```\n\nCombine public errors with `values.union`:\n\n```ts\nerrors: values.union(InvalidTodoText, TodoLimitReached),\n```\n\n## Catch and recover\n\nEvery Result operation has a partial, tag-based `catch`. Handlers receive the narrowed error type.\nUnmatched errors continue through the channel:\n\n```ts\nconst settings =\n  yield *\n  loadSettings().catch({\n    SettingsNotFound: () => defaultSettings,\n  });\n```\n\nReturn a plain value to recover. Return `Result.fail(...)` to map one error to another. Unknown tag\nnames fail the TypeScript check.\n\nUse `Result.try` for one catch boundary around several operations:\n\n```ts\nconst author =\n  yield *\n  Result.try(function* () {\n    const membership = yield* ctx.db.get(\"memberships\", topic.membershipId);\n    return yield* ctx.db.get(\"users\", membership.userId);\n  }).catch({\n    DocumentNotFound: () => Result.fail(InvalidAuthor({ topicId: topic.id })),\n  });\n```\n\nThere is no async variant. Ignotum operations always use `yield*` in server code.\n\n## Standalone results\n\n`Result.succeed` remains useful for helpers that return a Result:\n\n```ts\nfunction validateName(name: string) {\n  if (name.length === 0) {\n    return Result.fail(InvalidName({}));\n  }\n\n  return Result.succeed(name.trim());\n}\n```\n\nA handler can use the helper with `const name = yield* validateName(args.name)`. Normal handlers do\nnot wrap successful returns in `Result.succeed`.\n\n## Internal failures and defects\n\nDatabase outages, internal runtime failures, and thrown JavaScript exceptions are not application\nerrors. Ignotum logs their full cause and sends only:\n\n```ts\n{\n  _tag: \"InternalServerError\",\n  requestId: \"...\",\n}\n```\n\nEvery generated client function includes `InternalServerError` in its Result error union. The\nrequest ID links the client-visible failure to server logs without exposing private details.\n`InternalServerError` is reserved by Ignotum: never define it with `values.error` or include it in a\nfunction's `errors` schema.\n"],
+		["values.md", "# Values\n\nUse `values` validators to describe table fields, function arguments, return values, and application\nerrors. Each validator checks values at runtime and supplies the matching TypeScript type.\n\n| Validator                                 | TypeScript type                       | Notes                                                                                                |\n| ----------------------------------------- | ------------------------------------- | ---------------------------------------------------------------------------------------------------- |\n| `values.string()`                         | `string`                              |                                                                                                      |\n| `values.number()`                         | `number`                              | Accepts finite JavaScript numbers, including integers.                                               |\n| `values.integer()`                        | `number`                              | Accepts safe integers.                                                                               |\n| `values.boolean()`                        | `boolean`                             |                                                                                                      |\n| `values.date()`                           | `Date`                                | Accepts valid JavaScript dates.                                                                      |\n| `values.null()`                           | `null`                                | Accepts only `null`.                                                                                 |\n| `values.literal(value)`                   | The exact type of `value`             | Accepts one string, finite number, or boolean value.                                                 |\n| `values.literals(first, second, ...rest)` | A union of the supplied literal types | Requires at least two string, finite number, or boolean values.                                      |\n| `values.id(\"todos\")`                      | `Id<\"todos\">`                         | Accepts an ID for a table declared in the same schema. IDs for different tables are different types. |\n| `values.optional(value)`                  | `T \\| undefined`                      | Makes an object or table field optional. The field may be omitted.                                   |\n| `values.nullable(value)`                  | `T \\| null`                           | The value remains required unless it is also wrapped with `optional`.                                |\n| `values.array(value)`                     | `ReadonlyArray<T>`                    | Every item must match `value`.                                                                       |\n| `values.object(fields)`                   | An object matching `fields`           | Defines an object with known field names.                                                            |\n| `values.record(value)`                    | `Readonly<Record<string, T>>`         | Defines an object with dynamic string keys whose values all match `value`.                           |\n| `values.union(...values)`                 | A union of the supplied types         | Accepts a value matching any supplied validator.                                                     |\n| `values.never()`                          | `never`                               | No value can pass this validator.                                                                    |\n| `values.error(\"Name\", fields)`            | A tagged error object                 | Defines an application error whose `_tag` is the supplied name.                                      |\n\n`T` means the TypeScript type produced by the wrapped validator.\n\n## Examples\n\n```ts\nconst TodoStatus = values.literals(\"pending\", \"completed\");\n\nconst Todo = values.object({\n  status: TodoStatus,\n  scheduledAt: values.nullable(values.date()),\n  scores: values.record(values.integer()),\n  title: values.string(),\n});\n```\n\nUse `optional` when a field may be absent. Use `nullable` when a present field may contain `null`:\n\n```ts\nvalues.object({\n  nickname: values.optional(values.string()),\n  deletedAt: values.nullable(values.date()),\n});\n```\n"]
+	].map(([name, content]) => ({
+		content,
+		path: `.agents/skills/ignotum/references/${name}`
+	}))
+];
+//#endregion
+//#region src/cli/package-manager.ts
+var DependencyInstallationFailed = class extends Schema.TaggedError()("DependencyInstallationFailed", {
+	cause: Schema.optional(Schema.Defect()),
+	message: Schema.String,
+	path: Schema.String
+}) {};
+const installWith = Effect.fn("PackageManager.installWith")(function* (projectDirectory, packageManager) {
+	const exitCode = yield* (yield* ChildProcessSpawner.ChildProcessSpawner).exitCode(ChildProcess.make(packageManager, ["install"], {
+		cwd: projectDirectory,
+		stderr: "inherit",
+		stdin: "inherit",
+		stdout: "inherit"
+	}));
+	if (exitCode !== ChildProcessSpawner.ExitCode(0)) return yield* DependencyInstallationFailed.make({
+		message: `${packageManager} install exited with code ${exitCode} in ${projectDirectory}.`,
+		path: projectDirectory
+	});
+	return packageManager;
+});
+const installDependencies = Effect.fn("PackageManager.installDependencies")(function* (projectDirectory) {
+	return yield* installWith(projectDirectory, "pnpm").pipe(Effect.catchReasons("PlatformError", { NotFound: () => installWith(projectDirectory, "npm") }), Effect.catchTags({ PlatformError: (cause) => DependencyInstallationFailed.make({
+		cause,
+		message: `Could not run pnpm or npm in ${projectDirectory}.`,
+		path: projectDirectory
+	}) }));
+});
+//#endregion
+//#region src/cli/new-project.ts
+var ProjectDirectoryNotEmpty = class extends Schema.TaggedError()("ProjectDirectoryNotEmpty", {
+	message: Schema.String,
+	path: Schema.String
+}) {};
+var InvalidProjectName = class extends Schema.TaggedError()("InvalidProjectName", {
+	message: Schema.String,
+	path: Schema.String
+}) {};
+var GitInitializationFailed = class extends Schema.TaggedError()("GitInitializationFailed", {
+	cause: Schema.optional(Schema.Defect()),
+	message: Schema.String,
+	path: Schema.String
+}) {};
+const packageJson = (projectName) => `${JSON.stringify({
+	name: projectName,
+	private: true,
+	version: "0.0.0",
+	type: "module",
+	scripts: { typecheck: "ignotum codegen && tsc --noEmit" },
+	dependencies: { ignotum: "latest" },
+	devDependencies: { typescript: "^7.0.2" },
+	engines: { node: ">=22.18.0" }
+}, null, 2)}\n`;
+const tsconfig = `{
+  "compilerOptions": {
+    "target": "ES2023",
+    "lib": ["ES2023", "DOM", "DOM.Iterable"],
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "jsx": "react-jsx",
+    "jsxImportSource": "ignotum/client",
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": ["_generated", "client", "server", "shared"]
+}
+`;
+const gitignore = `node_modules/
+.ignotum/
+
+.env
+.env.*
+!.env.example
+
+.DS_Store
+Thumbs.db
+`;
+const schema = `import { defineSchema } from "ignotum/server";
+
+export default defineSchema(({ table, values }) => ({
+  counters: table({
+    value: values.number(),
+  }),
+}));
+`;
+const counterFunctions = `import { mutation, query, values } from "@/_generated/server.js";
+import { counterIncrement } from "@/shared/utils.js";
+
+export const get = query({
+  returns: values.number(),
+
+  handler: function* (ctx) {
+    const counters = yield* ctx.db.query("counters").collect();
+    return counters[0]?.value ?? 0;
+  },
+});
+
+export const increment = mutation({
+  returns: values.number(),
+
+  handler: function* (ctx) {
+    const counters = yield* ctx.db.query("counters").collect();
+    const counter = counters[0];
+    const value = (counter?.value ?? 0) + counterIncrement;
+
+    if (counter === undefined) {
+      yield* ctx.db.insert("counters", { value });
+    } else {
+      yield* ctx.db.patch("counters", counter.id, { value });
+    }
+
+    return value;
+  },
+});
+`;
+const app = `import { Result, useMutation, useQuery } from "ignotum/client";
+
+import { api } from "@/_generated/api.js";
+import { counterIncrement } from "@/shared/utils.js";
+
+export default function App() {
+  const count = useQuery(api.counter.get);
+  const increment = useMutation(api.counter.increment);
+
+  return (
+    <main class="mx-auto max-w-sm px-6 py-20 text-center">
+      <h1 class="text-2xl font-semibold">Counter</h1>
+      {Result.match(count, {
+        pending: () => <p class="mt-6">Loading...</p>,
+        value: (value) => (
+          <>
+            <p class="my-6 text-5xl tabular-nums">{value}</p>
+            <button
+              class="rounded bg-zinc-900 px-4 py-2 text-white"
+              type="button"
+              onClick={() => void increment()}
+            >
+              Increment by {counterIncrement}
+            </button>
+          </>
+        ),
+      })}
+    </main>
+  );
+}
+`;
+const utils = `export const counterIncrement = 1;
+`;
+const styles = `@import "tailwindcss";
+`;
+const readme = (projectName) => `# ${projectName}
+
+A small Ignotum counter app.
+
+## Getting started
+
+You need Node.js 22.18 or newer. The project generator installs dependencies by default. If you
+created the project with \`--no-install\`, install them now:
+
+\`\`\`sh
+npx ignotum install
+\`\`\`
+
+This command uses pnpm when it is installed and otherwise uses npm.
+
+Start the app:
+
+\`\`\`sh
+npx ignotum dev
+\`\`\`
+
+Open <http://127.0.0.1:3210>.
+
+The project generator creates \`_generated\`. The dev server checks those files before it starts
+and updates them when the schema or server functions change.
+
+## Project files
+
+- \`server/schema.ts\` defines the database tables.
+- \`server/counter.ts\` defines the query and mutation used by the counter.
+- \`client/App.tsx\` is the UI.
+- \`client/styles.css\` loads Tailwind CSS.
+- \`shared/utils.ts\` contains code shared across the app.
+- \`_generated\` contains Ignotum's generated types and bindings. Do not edit it by hand.
+
+Run the typechecker after a change:
+
+\`\`\`sh
+npx ignotum codegen
+npx tsc --noEmit
+\`\`\`
+
+## Claude Code
+
+If you use Claude Code, rename \`AGENTS.md\` to \`CLAUDE.md\` and \`.agents\` to \`.claude\` so it
+can find the project instructions and Ignotum skill.
+`;
+const projectFiles = (projectName) => [
+	{
+		content: app,
+		path: "client/App.tsx"
+	},
+	{
+		content: styles,
+		path: "client/styles.css"
+	},
+	{
+		content: counterFunctions,
+		path: "server/counter.ts"
+	},
+	{
+		content: schema,
+		path: "server/schema.ts"
+	},
+	{
+		content: utils,
+		path: "shared/utils.ts"
+	},
+	{
+		content: packageJson(projectName),
+		path: "package.json"
+	},
+	{
+		content: tsconfig,
+		path: "tsconfig.json"
+	},
+	{
+		content: gitignore,
+		path: ".gitignore"
+	},
+	{
+		content: readme(projectName),
+		path: "README.md"
+	},
+	...agentProjectFiles
+];
+const writeProjectFile = Effect.fn("NewProject.writeProjectFile")(function* (projectDirectory, file) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const filePath = path.join(projectDirectory, file.path);
+	yield* fileSystem.makeDirectory(path.dirname(filePath), { recursive: true });
+	yield* fileSystem.writeFileString(filePath, file.content, { flag: "wx" });
+});
+const gitExitCode = Effect.fn("NewProject.gitExitCode")(function* (projectDirectory, args) {
+	return yield* (yield* ChildProcessSpawner.ChildProcessSpawner).exitCode(ChildProcess.make("git", args, {
+		cwd: projectDirectory,
+		stderr: "ignore",
+		stdout: "ignore"
+	})).pipe(Effect.mapError((cause) => GitInitializationFailed.make({
+		cause,
+		message: `Could not run Git in ${projectDirectory}.`,
+		path: projectDirectory
+	})));
+});
+const runGit = Effect.fn("NewProject.runGit")(function* (projectDirectory, args, action) {
+	const exitCode = yield* gitExitCode(projectDirectory, args);
+	if (exitCode !== ChildProcessSpawner.ExitCode(0)) return yield* GitInitializationFailed.make({
+		message: `Git exited with code ${exitCode} while ${action} in ${projectDirectory}.`,
+		path: projectDirectory
+	});
+});
+const initializeGit = Effect.fn("NewProject.initializeGit")(function* (projectDirectory) {
+	yield* runGit(projectDirectory, ["init", "--quiet"], "initializing the repository");
+	yield* runGit(projectDirectory, ["add", "--all"], "staging the initial files");
+	const [hasName, hasEmail] = yield* Effect.all([gitExitCode(projectDirectory, ["config", "user.name"]), gitExitCode(projectDirectory, ["config", "user.email"])], { concurrency: "unbounded" }).pipe(Effect.map((exitCodes) => exitCodes.map((exitCode) => exitCode === ChildProcessSpawner.ExitCode(0))));
+	yield* runGit(projectDirectory, [
+		...hasName === true && hasEmail === true ? [] : [
+			"-c",
+			"user.name=Ignotum",
+			"-c",
+			"user.email=ignotum@localhost"
+		],
+		"commit",
+		"--quiet",
+		"--no-gpg-sign",
+		"-m",
+		"Init"
+	], "creating the initial commit");
+});
+const createProject = Effect.fn("NewProject.createProject")(function* (options) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const projectDirectory = path.resolve(options.currentDirectory, options.directory);
+	const projectName = String.kebabCase(path.basename(projectDirectory));
+	if (projectName.length === 0) return yield* InvalidProjectName.make({
+		message: `Could not derive a package name from ${projectDirectory}.`,
+		path: projectDirectory
+	});
+	if (yield* fileSystem.exists(projectDirectory)) {
+		if ((yield* fileSystem.stat(projectDirectory)).type !== "Directory") return yield* ProjectDirectoryNotEmpty.make({
+			message: `${projectDirectory} already exists and is not an empty directory.`,
+			path: projectDirectory
+		});
+		if ((yield* fileSystem.readDirectory(projectDirectory)).length > 0) return yield* ProjectDirectoryNotEmpty.make({
+			message: `${projectDirectory} is not empty. Choose an empty directory.`,
+			path: projectDirectory
+		});
+	} else yield* fileSystem.makeDirectory(projectDirectory, { recursive: true });
+	yield* Effect.forEach(projectFiles(projectName), (file) => writeProjectFile(projectDirectory, file), { discard: true });
+	yield* generate(projectDirectory);
+	const packageManager = options.install ? yield* installDependencies(projectDirectory) : null;
+	if (options.git) yield* initializeGit(projectDirectory);
+	return {
+		directory: projectDirectory,
+		gitInitialized: options.git,
+		packageManager,
+		projectName
+	};
+});
+//#endregion
+//#region src/cli/command.ts
+const DevPort = Schema.Int.check(Schema.isBetween({
+	minimum: 1,
+	maximum: 65535
+}));
+const codegen = Command.make("codegen", {}, Effect.fn("codegen")(function* () {
+	const path = yield* Path.Path;
+	const terminal = yield* Terminal.Terminal;
+	const result = yield* generate(path.resolve(".")).pipe(Effect.mapError((error) => CliError.UserError.make({
+		cause: error,
+		userMessage: error.message
+	})));
+	yield* terminal.display(`Generated ${result.written.length} file${result.written.length === 1 ? "" : "s"}; ${result.unchanged.length} unchanged.\n`);
+}));
+const resetDevDatabaseCommand = Command.make("reset", {}, Effect.fn("dev db reset")(function* () {
+	const path = yield* Path.Path;
+	const terminal = yield* Terminal.Terminal;
+	const result = yield* resetDevDatabase(path.resolve(".")).pipe(Effect.mapError((error) => CliError.UserError.make({
+		cause: error,
+		userMessage: error.message
+	})));
+	const message = result.removed === 0 ? `Development database is already empty: ${result.databasePath}\n` : `Reset development database: ${result.databasePath}\n`;
+	yield* terminal.display(message);
+})).pipe(Command.withDescription("Delete the local SQLite development database."));
+const devDatabase = Command.make("db").pipe(Command.withDescription("Manage the local development database."), Command.withSubcommands([resetDevDatabaseCommand]));
+const dev = Command.make("dev", {
+	host: Flag.string("host").pipe(Flag.withDefault("127.0.0.1")),
+	open: Flag.boolean("open").pipe(Flag.withDefault(false)),
+	port: Flag.integer("port").pipe(Flag.withSchema(DevPort), Flag.withDefault(3210))
+}, Effect.fn("dev")(function* ({ host, open, port }) {
+	const path = yield* Path.Path;
+	return yield* dev$1({
+		host,
+		open,
+		port,
+		projectDirectory: path.resolve(".")
+	}).pipe(Effect.mapError((error) => CliError.UserError.make({
+		cause: error,
+		userMessage: error.message
+	})));
+})).pipe(Command.withDescription("Run the local Ignotum development server."), Command.withSubcommands([devDatabase]));
+const install = Command.make("install", {}, Effect.fn("install")(function* () {
+	const path = yield* Path.Path;
+	const terminal = yield* Terminal.Terminal;
+	const packageManager = yield* installDependencies(path.resolve(".")).pipe(Effect.mapError((error) => CliError.UserError.make({
+		cause: error,
+		userMessage: error.message
+	})));
+	yield* terminal.display(`Installed dependencies with ${packageManager}.\n`);
+})).pipe(Command.withDescription("Install dependencies with pnpm, or npm when pnpm is unavailable."));
+const newProject = Command.make("new", {
+	directory: Argument.string("directory").pipe(Argument.withDescription("Directory to create. Use \".\" for the current directory.")),
+	git: Flag.boolean("git").pipe(Flag.withDescription("Initialize a Git repository. Use --no-git to skip it."), Flag.withDefault(true)),
+	install: Flag.boolean("install").pipe(Flag.withDescription("Install dependencies. Use --no-install to skip it."), Flag.withDefault(true))
+}, Effect.fn("new")(function* ({ directory, git, install }) {
+	const path = yield* Path.Path;
+	const terminal = yield* Terminal.Terminal;
+	const currentDirectory = path.resolve(".");
+	const result = yield* createProject({
+		currentDirectory,
+		directory,
+		git,
+		install
+	}).pipe(Effect.mapError((error) => CliError.UserError.make({
+		cause: error,
+		userMessage: error.message
+	})));
+	const changeDirectory = result.directory === currentDirectory ? "" : `  cd ${directory}\n`;
+	const installCommand = result.packageManager === null ? "  npx ignotum install\n" : "";
+	yield* terminal.display(`Created ${result.projectName} in ${result.directory}.\n\nNext steps:\n${changeDirectory}${installCommand}  npx ignotum dev\n`);
+})).pipe(Command.withDescription("Create a new Ignotum app in an empty directory."), Command.withExamples([{
+	command: "ignotum new my-app",
+	description: "Create an app in a new directory."
+}, {
+	command: "ignotum new . --no-git --no-install",
+	description: "Create an app in the current directory without Git or dependency installation."
+}]));
+const ignotum = Command.make("ignotum").pipe(Command.withSubcommands([
+	newProject,
+	install,
+	codegen,
+	dev
+]));
+const main = () => {
+	ignotum.pipe(Command.run({ version }), Effect.provide(NodeServices.layer), NodeRuntime.runMain);
+};
+//#endregion
+//#region src/cli/bin.ts
+main();
+//#endregion
+export {};
+
+//# sourceMappingURL=bin.mjs.map