ignotum 0.0.0 → 0.0.2

package/dist/runtime/schema-CNEVLF7D.js

@@ -0,0 +1,116 @@
+import { t as ErrorBrand } from "./result-B2W-z2wG.js";
+import { Schema } from "effect";
+//#region ../contracts/dist/runtime/id.js
+const GeneratedId = Schema.String.check(Schema.isPattern(/^[0-9a-z]{24}$/)).pipe(Schema.brand("ignotum/id"));
+//#endregion
+//#region ../contracts/dist/schema/values.js
+const LiteralValueSchema = Schema.Union([
+	Schema.String,
+	Schema.Finite,
+	Schema.Boolean
+]);
+const table = (fields) => {
+	const tableFields = fields;
+	return {
+		_tag: "Table",
+		fields: tableFields,
+		schema: Schema.Struct(tableFields)
+	};
+};
+const string = () => Schema.String;
+const number = () => Schema.Finite;
+const integer = () => Schema.Int;
+const boolean = () => Schema.Boolean;
+const date = () => Schema.DateFromMillis;
+const never = () => Schema.Never;
+const nullValue = () => Schema.Null;
+const literal = (value) => {
+	Schema.decodeSync(LiteralValueSchema)(value);
+	return Schema.Literal(value);
+};
+const literals = (...members) => {
+	Schema.decodeSync(Schema.Array(LiteralValueSchema))(members);
+	return Schema.Literals(members);
+};
+const makeIdSchema = (tableName) => {
+	const identifier = `ignotum/id/${tableName}`;
+	return GeneratedId.pipe(Schema.brand(identifier), Schema.annotate({ "ignotum/table": tableName }));
+};
+const id = (tableName) => makeIdSchema(tableName);
+const array = (value) => Schema.Array(value);
+const object = (fields) => Schema.Struct(fields);
+const optional = (value) => Schema.optional(value);
+const nullable = (value) => Schema.NullOr(value);
+const record = (value) => Schema.Record(Schema.String, value);
+const union = (...members) => Schema.Union(members);
+const error = (tag, fields) => {
+	if (tag === "InternalServerError") throw new Error("The error tag 'InternalServerError' is reserved by Ignotum.");
+	const errorFields = { ...fields };
+	Reflect.deleteProperty(errorFields, "_tag");
+	const schema = Schema.TaggedStruct(tag, errorFields).pipe(Schema.brand(ErrorBrand));
+	const make = (input) => schema.make(input);
+	const definition = Object.assign(make, schema);
+	Object.setPrototypeOf(definition, Object.getPrototypeOf(schema));
+	return definition;
+};
+const values = {
+	array,
+	boolean,
+	date,
+	error,
+	id,
+	integer,
+	literal,
+	literals,
+	never,
+	null: nullValue,
+	nullable,
+	number,
+	object,
+	optional,
+	record,
+	string,
+	union
+};
+const bindValues = () => values;
+//#endregion
+//#region ../contracts/dist/runtime/schema.js
+const FunctionSchemaTypeId = Symbol.for("ignotum/runtime/schema/FunctionSchema");
+const attachFunctionSchema = (schema) => (definition) => {
+	Object.defineProperty(definition, FunctionSchemaTypeId, {
+		configurable: false,
+		enumerable: false,
+		value: schema,
+		writable: false
+	});
+	return definition;
+};
+//#endregion
+//#region ../contracts/dist/schema/index.js
+const SchemaDefinitionTypeId = Symbol.for("ignotum/schema/SchemaDefinition");
+const defineSchema = (define) => ({
+	_tag: "Schema",
+	[SchemaDefinitionTypeId]: define({
+		table,
+		values
+	})
+});
+const makeFunctionBuilder = (schema, kind) => {
+	const define = (definition) => attachFunctionSchema(schema)({
+		_tag: kind,
+		...definition
+	});
+	return define;
+};
+const makeFunctionBuilders = (schema) => ({
+	mutation: makeFunctionBuilder(schema, "Mutation"),
+	query: makeFunctionBuilder(schema, "Query")
+});
+const bindSchema = (schema) => ({
+	values: bindValues(),
+	...makeFunctionBuilders(schema)
+});
+//#endregion
+export { bindSchema as n, defineSchema as r, SchemaDefinitionTypeId as t };
+
+//# sourceMappingURL=schema-CNEVLF7D.js.map

package/dist/runtime/schema-CNEVLF7D.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-CNEVLF7D.js","names":[],"sources":["../../../contracts/dist/runtime/id.js","../../../contracts/dist/schema/values.js","../../../contracts/dist/runtime/schema.js","../../../contracts/dist/schema/index.js"],"sourcesContent":["import { Schema } from \"effect\";\n//#region src/runtime/id.ts\nconst IdAlphabet = \"0123456789abcdefghijklmnopqrstuvwxyz\";\nconst IdLength = 24;\nconst GeneratedId = Schema.String.check(Schema.isPattern(/^[0-9a-z]{24}$/)).pipe(Schema.brand(\"ignotum/id\"));\n//#endregion\nexport { GeneratedId, IdAlphabet, IdLength };\n\n//# sourceMappingURL=id.js.map","import { GeneratedId } from \"../runtime/id.js\";\nimport { ErrorBrand } from \"../runtime/result.js\";\nimport { Schema } from \"effect\";\n//#region src/schema/values.ts\nconst LiteralValueSchema = Schema.Union([\n\tSchema.String,\n\tSchema.Finite,\n\tSchema.Boolean\n]);\nconst table = (fields) => {\n\tconst tableFields = fields;\n\treturn {\n\t\t_tag: \"Table\",\n\t\tfields: tableFields,\n\t\tschema: Schema.Struct(tableFields)\n\t};\n};\nconst string = () => Schema.String;\nconst number = () => Schema.Finite;\nconst integer = () => Schema.Int;\nconst boolean = () => Schema.Boolean;\nconst date = () => Schema.DateFromMillis;\nconst never = () => Schema.Never;\nconst nullValue = () => Schema.Null;\nconst literal = (value) => {\n\tSchema.decodeSync(LiteralValueSchema)(value);\n\treturn Schema.Literal(value);\n};\nconst literals = (...members) => {\n\tSchema.decodeSync(Schema.Array(LiteralValueSchema))(members);\n\treturn Schema.Literals(members);\n};\nconst makeIdSchema = (tableName) => {\n\tconst identifier = `ignotum/id/${tableName}`;\n\treturn GeneratedId.pipe(Schema.brand(identifier), Schema.annotate({ \"ignotum/table\": tableName }));\n};\nconst id = (tableName) => makeIdSchema(tableName);\nconst array = (value) => Schema.Array(value);\nconst object = (fields) => Schema.Struct(fields);\nconst optional = (value) => Schema.optional(value);\nconst nullable = (value) => Schema.NullOr(value);\nconst record = (value) => Schema.Record(Schema.String, value);\nconst union = (...members) => Schema.Union(members);\nconst error = (tag, fields) => {\n\tif (tag === \"InternalServerError\") throw new Error(\"The error tag 'InternalServerError' is reserved by Ignotum.\");\n\tconst errorFields = { ...fields };\n\tReflect.deleteProperty(errorFields, \"_tag\");\n\tconst schema = Schema.TaggedStruct(tag, errorFields).pipe(Schema.brand(ErrorBrand));\n\tconst make = (input) => schema.make(input);\n\tconst definition = Object.assign(make, schema);\n\tObject.setPrototypeOf(definition, Object.getPrototypeOf(schema));\n\treturn definition;\n};\nconst values = {\n\tarray,\n\tboolean,\n\tdate,\n\terror,\n\tid,\n\tinteger,\n\tliteral,\n\tliterals,\n\tnever,\n\tnull: nullValue,\n\tnullable,\n\tnumber,\n\tobject,\n\toptional,\n\trecord,\n\tstring,\n\tunion\n};\nconst bindValues = () => values;\n//#endregion\nexport { bindValues, table, values };\n\n//# sourceMappingURL=values.js.map","//#region src/runtime/schema.ts\nconst FunctionSchemaTypeId = Symbol.for(\"ignotum/runtime/schema/FunctionSchema\");\nconst attachFunctionSchema = (schema) => (definition) => {\n\tObject.defineProperty(definition, FunctionSchemaTypeId, {\n\t\tconfigurable: false,\n\t\tenumerable: false,\n\t\tvalue: schema,\n\t\twritable: false\n\t});\n\treturn definition;\n};\nconst getFunctionSchema = (value) => value[FunctionSchemaTypeId];\n//#endregion\nexport { FunctionSchemaTypeId, attachFunctionSchema, getFunctionSchema };\n\n//# sourceMappingURL=schema.js.map","import { Result } from \"../runtime/result.js\";\nimport { bindValues, table, values } from \"./values.js\";\nimport { attachFunctionSchema } from \"../runtime/schema.js\";\n//#region src/schema/types.ts\nconst SchemaDefinitionTypeId = Symbol.for(\"ignotum/schema/SchemaDefinition\");\n//#endregion\n//#region src/schema/definition.ts\nconst defineSchema = (define) => ({\n\t_tag: \"Schema\",\n\t[SchemaDefinitionTypeId]: define({\n\t\ttable,\n\t\tvalues\n\t})\n});\n//#endregion\n//#region src/schema/server.ts\nconst makeFunctionBuilder = (schema, kind) => {\n\tconst define = (definition) => attachFunctionSchema(schema)({\n\t\t_tag: kind,\n\t\t...definition\n\t});\n\treturn define;\n};\nconst makeFunctionBuilders = (schema) => ({\n\tmutation: makeFunctionBuilder(schema, \"Mutation\"),\n\tquery: makeFunctionBuilder(schema, \"Query\")\n});\nconst bindSchema = (schema) => ({\n\tvalues: bindValues(),\n\t...makeFunctionBuilders(schema)\n});\n//#endregion\nexport { Result, SchemaDefinitionTypeId, bindSchema, bindValues, defineSchema, table, values };\n\n//# sourceMappingURL=index.js.map"],"mappings":";;;AAIA,MAAM,cAAc,OAAO,OAAO,MAAM,OAAO,UAAU,gBAAgB,CAAC,CAAC,CAAC,KAAK,OAAO,MAAM,YAAY,CAAC;;;ACA3G,MAAM,qBAAqB,OAAO,MAAM;CACvC,OAAO;CACP,OAAO;CACP,OAAO;AACR,CAAC;AACD,MAAM,SAAS,WAAW;CACzB,MAAM,cAAc;CACpB,OAAO;EACN,MAAM;EACN,QAAQ;EACR,QAAQ,OAAO,OAAO,WAAW;CAClC;AACD;AACA,MAAM,eAAe,OAAO;AAC5B,MAAM,eAAe,OAAO;AAC5B,MAAM,gBAAgB,OAAO;AAC7B,MAAM,gBAAgB,OAAO;AAC7B,MAAM,aAAa,OAAO;AAC1B,MAAM,cAAc,OAAO;AAC3B,MAAM,kBAAkB,OAAO;AAC/B,MAAM,WAAW,UAAU;CAC1B,OAAO,WAAW,kBAAkB,CAAC,CAAC,KAAK;CAC3C,OAAO,OAAO,QAAQ,KAAK;AAC5B;AACA,MAAM,YAAY,GAAG,YAAY;CAChC,OAAO,WAAW,OAAO,MAAM,kBAAkB,CAAC,CAAC,CAAC,OAAO;CAC3D,OAAO,OAAO,SAAS,OAAO;AAC/B;AACA,MAAM,gBAAgB,cAAc;CACnC,MAAM,aAAa,cAAc;CACjC,OAAO,YAAY,KAAK,OAAO,MAAM,UAAU,GAAG,OAAO,SAAS,EAAE,iBAAiB,UAAU,CAAC,CAAC;AAClG;AACA,MAAM,MAAM,cAAc,aAAa,SAAS;AAChD,MAAM,SAAS,UAAU,OAAO,MAAM,KAAK;AAC3C,MAAM,UAAU,WAAW,OAAO,OAAO,MAAM;AAC/C,MAAM,YAAY,UAAU,OAAO,SAAS,KAAK;AACjD,MAAM,YAAY,UAAU,OAAO,OAAO,KAAK;AAC/C,MAAM,UAAU,UAAU,OAAO,OAAO,OAAO,QAAQ,KAAK;AAC5D,MAAM,SAAS,GAAG,YAAY,OAAO,MAAM,OAAO;AAClD,MAAM,SAAS,KAAK,WAAW;CAC9B,IAAI,QAAQ,uBAAuB,MAAM,IAAI,MAAM,6DAA6D;CAChH,MAAM,cAAc,EAAE,GAAG,OAAO;CAChC,QAAQ,eAAe,aAAa,MAAM;CAC1C,MAAM,SAAS,OAAO,aAAa,KAAK,WAAW,CAAC,CAAC,KAAK,OAAO,MAAM,UAAU,CAAC;CAClF,MAAM,QAAQ,UAAU,OAAO,KAAK,KAAK;CACzC,MAAM,aAAa,OAAO,OAAO,MAAM,MAAM;CAC7C,OAAO,eAAe,YAAY,OAAO,eAAe,MAAM,CAAC;CAC/D,OAAO;AACR;AACA,MAAM,SAAS;CACd;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA,MAAM;CACN;CACA;CACA;CACA;CACA;CACA;CACA;AACD;AACA,MAAM,mBAAmB;;;ACvEzB,MAAM,uBAAuB,OAAO,IAAI,uCAAuC;AAC/E,MAAM,wBAAwB,YAAY,eAAe;CACxD,OAAO,eAAe,YAAY,sBAAsB;EACvD,cAAc;EACd,YAAY;EACZ,OAAO;EACP,UAAU;CACX,CAAC;CACD,OAAO;AACR;;;ACNA,MAAM,yBAAyB,OAAO,IAAI,iCAAiC;AAG3E,MAAM,gBAAgB,YAAY;CACjC,MAAM;EACL,yBAAyB,OAAO;EAChC;EACA;CACD,CAAC;AACF;AAGA,MAAM,uBAAuB,QAAQ,SAAS;CAC7C,MAAM,UAAU,eAAe,qBAAqB,MAAM,CAAC,CAAC;EAC3D,MAAM;EACN,GAAG;CACJ,CAAC;CACD,OAAO;AACR;AACA,MAAM,wBAAwB,YAAY;CACzC,UAAU,oBAAoB,QAAQ,UAAU;CAChD,OAAO,oBAAoB,QAAQ,OAAO;AAC3C;AACA,MAAM,cAAc,YAAY;CAC/B,QAAQ,WAAW;CACnB,GAAG,qBAAqB,MAAM;AAC/B"}

package/dist/runtime/server.d.ts

@@ -0,0 +1,9 @@
+import { r as ErrorValue, s as Result$1 } from "./result-C1ZdsM6Y.js";
+import { i as defineSchema$1, n as SchemaAuthoring, t as DefinedSchema } from "./index-BgWROoyk.js";
+//#region src/server/index.d.ts
+declare const Result: typeof Result$1;
+type Result<Success, Failure extends ErrorValue> = Result$1<Success, Failure>;
+declare const defineSchema: typeof defineSchema$1;
+//#endregion
+export { type DefinedSchema, Result, type SchemaAuthoring, defineSchema };
+//# sourceMappingURL=server.d.ts.map

package/dist/runtime/server.js

@@ -0,0 +1,9 @@
+import { n as Result$1 } from "./result-B2W-z2wG.js";
+import { r as defineSchema$1 } from "./schema-CNEVLF7D.js";
+//#region src/server/index.ts
+const Result = Result$1;
+const defineSchema = defineSchema$1;
+//#endregion
+export { Result, defineSchema };
+
+//# sourceMappingURL=server.js.map

package/dist/runtime/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","names":["contractResult","defineContractSchema"],"sources":["../../src/server/index.ts"],"sourcesContent":["import { Result as contractResult } from \"@ignotum/contracts/runtime/result\";\nimport type { ErrorValue, Result as ContractResult } from \"@ignotum/contracts/runtime/result\";\nimport { defineSchema as defineContractSchema } from \"@ignotum/contracts/schema\";\n\nexport const Result: typeof contractResult = contractResult;\nexport type Result<Success, Failure extends ErrorValue> = ContractResult<Success, Failure>;\nexport const defineSchema: typeof defineContractSchema = defineContractSchema;\nexport type { DefinedSchema, SchemaAuthoring } from \"@ignotum/contracts/schema\";\n"],"mappings":";;;AAIA,MAAa,SAAgCA;AAE7C,MAAa,eAA4CC"}

package/package.json

@@ -1,4 +1,83 @@
 {
   "name": "ignotum",
-  "version": "0.0.0"
-}
+  "version": "0.0.2",
+  "description": "Ignotum is an opinionated TypeScript application cloud.",
+  "author": "Johannes Schießl",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/johannesschiessl/ignotum.git",
+    "directory": "packages/ignotum"
+  },
+  "bin": {
+    "ignotum": "dist/cli/bin.mjs"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    "./server": {
+      "@ignotum/source": "./src/server/index.ts",
+      "types": "./dist/runtime/server.d.ts",
+      "import": "./dist/runtime/server.js"
+    },
+    "./client": {
+      "@ignotum/source": "./src/client/index.ts",
+      "types": "./dist/runtime/client.d.ts",
+      "import": "./dist/runtime/client.js"
+    },
+    "./client/jsx-dev-runtime": {
+      "@ignotum/source": "./src/client/jsx-dev-runtime.ts",
+      "types": "./dist/runtime/client/jsx-dev-runtime.d.ts",
+      "import": "./dist/runtime/client/jsx-dev-runtime.js"
+    },
+    "./client/jsx-runtime": {
+      "@ignotum/source": "./src/client/jsx-runtime.ts",
+      "types": "./dist/runtime/client/jsx-runtime.d.ts",
+      "import": "./dist/runtime/client/jsx-runtime.js"
+    },
+    "./internal/api": {
+      "@ignotum/source": "./src/internal/api.ts",
+      "types": "./dist/runtime/internal/api.d.ts",
+      "import": "./dist/runtime/internal/api.js"
+    },
+    "./internal/server": {
+      "@ignotum/source": "./src/internal/server.ts",
+      "types": "./dist/runtime/internal/server.d.ts",
+      "import": "./dist/runtime/internal/server.js"
+    },
+    "./internal/types": {
+      "@ignotum/source": "./src/internal/types.ts",
+      "types": "./dist/runtime/internal/types.d.ts",
+      "import": "./dist/runtime/internal/types.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@effect/platform-node": "4.0.0-rc.111",
+    "@effect/sql-sqlite-node": "4.0.0-rc.111",
+    "@prefresh/vite": "3.0.1",
+    "@tailwindcss/vite": "4.3.3",
+    "effect": "4.0.0-rc.111",
+    "nanoid": "6.0.1",
+    "preact": "10.29.8",
+    "tailwindcss": "4.3.3",
+    "vite": "8.2.2"
+  },
+  "devDependencies": {
+    "@ignotum/contracts": "0.0.0",
+    "@ignotum/runtime": "0.0.0"
+  },
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "typecheck": "tsc -p tsconfig.json"
+  }
+}

package/src/cli/agent-files.ts

@@ -0,0 +1,35 @@
+import agents from "../../../../docs/agent/AGENTS.md?raw";
+import skill from "../../../../docs/agent/skills/ignotum/SKILL.md?raw";
+import client from "../../../../docs/user/client.md?raw";
+import devServer from "../../../../docs/user/dev-server.md?raw";
+import gettingStarted from "../../../../docs/user/getting-started.md?raw";
+import index from "../../../../docs/user/index.md?raw";
+import manualSetup from "../../../../docs/user/manual-setup.md?raw";
+import schema from "../../../../docs/user/schema.md?raw";
+import serverFunctions from "../../../../docs/user/server-functions.md?raw";
+import values from "../../../../docs/user/values.md?raw";
+
+export interface ProjectFile {
+  readonly content: string;
+  readonly path: string;
+}
+
+const references = [
+  ["client.md", client],
+  ["dev-server.md", devServer],
+  ["getting-started.md", gettingStarted],
+  ["index.md", index],
+  ["manual-setup.md", manualSetup],
+  ["schema.md", schema],
+  ["server-functions.md", serverFunctions],
+  ["values.md", values],
+] as const;
+
+export const agentProjectFiles: ReadonlyArray<ProjectFile> = [
+  { content: agents, path: "AGENTS.md" },
+  { content: skill, path: ".agents/skills/ignotum/SKILL.md" },
+  ...references.map(([name, content]) => ({
+    content,
+    path: `.agents/skills/ignotum/references/${name}`,
+  })),
+];

package/src/cli/bin.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { main } from "./command.js";
+
+main();

package/src/cli/client-plugin.ts

@@ -0,0 +1,66 @@
+import type { Plugin } from "vite";
+
+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)
+`;
+
+export const ignotumClientPlugin = (): Plugin => ({
+  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 ?? "/";
+
+      void server
+        .transformIndexHtml(requestUrl, document)
+        .then((html) => {
+          response.statusCode = 200;
+          response.setHeader("Content-Type", "text/html; charset=utf-8");
+          response.end(request.method === "HEAD" ? undefined : html);
+        })
+        .catch(next);
+    });
+  },
+
+  load: (id) => (id === resolvedClientEntryId ? clientEntry : undefined),
+
+  resolveId: (id) => (id === clientEntryId ? resolvedClientEntryId : undefined),
+});

package/src/cli/codegen.ts

@@ -0,0 +1,203 @@
+import { Array, Effect, FileSystem, Path, Schema, String } from "effect";
+
+import { FunctionNamePart } from "@ignotum/contracts/runtime/sync";
+
+const generatedHeader = "// Generated by `ignotum codegen`. Do not edit.";
+
+export class SchemaNotFound extends Schema.TaggedError<SchemaNotFound>()("SchemaNotFound", {
+  message: Schema.String,
+  path: Schema.String,
+}) {}
+
+export class InvalidFunctionModuleName extends Schema.TaggedError<InvalidFunctionModuleName>()(
+  "InvalidFunctionModuleName",
+  {
+    message: Schema.String,
+    path: Schema.String,
+  },
+) {}
+
+export class GeneratedFileConflict extends Schema.TaggedError<GeneratedFileConflict>()(
+  "GeneratedFileConflict",
+  {
+    message: Schema.String,
+    path: Schema.String,
+  },
+) {}
+
+interface GeneratedOutput {
+  readonly content: string;
+  readonly path: string;
+}
+
+export interface CodegenResult {
+  readonly functionModules: ReadonlyArray<string>;
+  readonly written: ReadonlyArray<string>;
+  readonly unchanged: ReadonlyArray<string>;
+}
+
+const isFunctionModuleFile = (fileName: string): boolean =>
+  fileName.endsWith(".ts") &&
+  !fileName.endsWith(".test.ts") &&
+  !fileName.endsWith(".spec.ts") &&
+  fileName !== "index.ts" &&
+  fileName !== "schema.ts" &&
+  !fileName.startsWith("_");
+
+const moduleNameFromFile = (filePath: string, fileName: string) => {
+  const moduleName = fileName.slice(0, -".ts".length);
+
+  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 = (): string => `${generatedHeader}
+
+import { bindSchema } from "ignotum/internal/server";
+
+import schema from "../server/schema.js";
+
+export const { mutation, query, values } = bindSchema(schema);
+`;
+
+const renderTypes = (): string => `${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: ReadonlyArray<string>): string => {
+  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: GeneratedOutput) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const exists = yield* fileSystem.exists(output.path);
+
+  if (!exists) {
+    return "write" as const;
+  }
+
+  const current = yield* fileSystem.readFileString(output.path);
+
+  if (current === output.content) {
+    return "unchanged" as const;
+  }
+
+  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" as const;
+});
+
+const writeOutput = Effect.fn("Codegen.writeOutput")(function* (output: GeneratedOutput) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const directory = 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);
+    }),
+  );
+});
+
+export const generate = Effect.fn("Codegen.generate")(function* (projectDirectory: string) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const serverDirectory = path.join(projectDirectory, "server");
+  const schemaPath = path.join(serverDirectory, "schema.ts");
+  const schemaExists = yield* fileSystem.exists(schemaPath);
+
+  if (!schemaExists) {
+    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: ReadonlyArray<GeneratedOutput> = [
+    {
+      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 } satisfies CodegenResult;
+});