@shivaedev/build 0.0.0-stage → 0.1.0

package/dist/settleOrphans.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settleOrphans.js","sourceRoot":"","sources":["../src/settleOrphans.ts"],"names":[],"mappings":"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"}

package/dist/specifiers.d.ts

@@ -0,0 +1,4 @@
+import { Effect, Path } from "effect";
+export declare function matchingKey(entries: readonly (readonly [string, unknown])[], relativeFile: string): string | undefined;
+export declare const specifierFor: (root: string, from: string, file: string) => Effect.Effect<string | undefined, import("effect/PlatformError").PlatformError | import("effect/Schema").SchemaError, import("effect/FileSystem").FileSystem | Path.Path>;
+//# sourceMappingURL=specifiers.d.ts.map

package/dist/specifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"specifiers.d.ts","sourceRoot":"","sources":["../src/specifiers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAU,IAAI,EAAE,MAAM,QAAQ,CAAC;AAsB9C,wBAAgB,WAAW,CAAC,OAAO,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CActH;AAGD,eAAO,MAAM,YAAY,yNAevB,CAAC"}

package/dist/specifiers.js

@@ -0,0 +1,52 @@
+import { Effect, Option, Path } from "effect";
+import { packageScopeOf } from "#packageScope.ts";
+function targetsOf(value) {
+    if (typeof value === "string") {
+        return [value];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap(targetsOf);
+    }
+    return typeof value === "object" && value !== null ? Object.values(value).flatMap(targetsOf) : [];
+}
+function exportEntries(exports) {
+    if (typeof exports !== "object" || exports === null || Array.isArray(exports)) {
+        return exports === undefined ? [] : [[".", exports]];
+    }
+    const entries = Object.entries(exports);
+    return entries.every(([key]) => key.startsWith(".")) ? entries : [[".", exports]];
+}
+// The key of the first entry whose target names the file, with its wildcard filled in.
+export function matchingKey(entries, relativeFile) {
+    for (const [key, value] of entries) {
+        for (const target of targetsOf(value)) {
+            const [prefix = "", suffix, ...rest] = target.split("*");
+            if (suffix === undefined && target === relativeFile) {
+                return key;
+            }
+            const fits = suffix !== undefined && rest.length === 0 && relativeFile.length >= prefix.length + suffix.length;
+            if (fits && relativeFile.startsWith(prefix) && relativeFile.endsWith(suffix)) {
+                return key.replace("*", relativeFile.slice(prefix.length, relativeFile.length - suffix.length));
+            }
+        }
+    }
+    return undefined;
+}
+// How the generated file at `from` imports `file`: the project's own imports, another package's exports, else a relative path.
+export const specifierFor = Effect.fn("Build.specifierFor")(function* (root, from, file) {
+    const path = yield* Path.Path;
+    const scope = yield* packageScopeOf(file);
+    if (Option.isNone(scope)) {
+        return undefined;
+    }
+    const { directory, manifest } = scope.value;
+    const relativeFile = `./${path.relative(directory, file)}`;
+    if (directory === root) {
+        const own = matchingKey(Object.entries(manifest.imports ?? {}), relativeFile);
+        const relative = path.relative(path.dirname(from), file);
+        return own ?? (relative.startsWith(".") ? relative : `./${relative}`);
+    }
+    const exported = matchingKey(exportEntries(manifest.exports), relativeFile);
+    return exported === undefined || manifest.name === undefined ? undefined : `${manifest.name}${exported.slice(1)}`;
+});
+//# sourceMappingURL=specifiers.js.map

package/dist/specifiers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"specifiers.js","sourceRoot":"","sources":["../src/specifiers.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,92 @@
 {
   "name": "@shivaedev/build",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "An application's build setup: its Vite and Vitest configuration, and the generated wire and browser contract of each defined module",
+  "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/build#readme",
+  "bugs": {
+    "url": "https://github.com/ShivaeDev/platform/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ShivaeDev/platform.git",
+    "directory": "packages/build"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "imports": {
+    "#test/*": "./src/test-support/*",
+    "#*.ts": {
+      "@shivaedev/source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "#package.json": "./package.json"
+  },
+  "exports": {
+    "./*.ts": {
+      "@shivaedev/source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "shivaedev-build": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.spec.ts",
+    "!src/**/test-support",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "dependencies": {
+    "@shivaedev/heavy-lock": "0.11.2",
+    "@shivaedev/quality": "0.77.0",
+    "typescript": "npm:@typescript/typescript6@6.0.2"
+  },
+  "devDependencies": {
+    "@effect/platform-node": "4.1.2",
+    "@effect/platform-node-shared": "4.1.2",
+    "@shivaedev/changes": "0.12.0",
+    "@shivaedev/contract": "0.44.0",
+    "@shivaedev/errors": "0.12.0",
+    "@shivaedev/test-story": "0.47.0",
+    "@types/node": "24.19.2",
+    "@typescript/native": "npm:typescript@7.0.2",
+    "effect": "4.1.2",
+    "vite": "8.3.5",
+    "vitest": "5.1.0"
+  },
+  "peerDependencies": {
+    "@effect/platform-node": "4.1.2",
+    "@effect/platform-node-shared": "4.1.2",
+    "effect": "4.1.2",
+    "vite": "8.3.5",
+    "vitest": "5.1.0"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    },
+    "vitest": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc --project tsconfig.build.json",
+    "ready": "pnpm typecheck && pnpm test && pnpm build",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
 }

package/src/BuildFailure.ts

@@ -0,0 +1,5 @@
+import { Data } from "effect";
+
+export class BuildFailure extends Data.TaggedError("BuildFailure")<{
+	readonly message: string;
+}> {}

package/src/adapters/appTestConfig.ts

@@ -0,0 +1,18 @@
+import { fileURLToPath } from "node:url";
+import type { ViteUserConfig } from "vitest/config";
+import { type TestProjectsOptions, testProjects } from "@shivaedev/quality/adapters/testProjects.ts";
+
+export function appTestConfig(conditions: string[] = [], options: TestProjectsOptions = {}): ViteUserConfig {
+	const server = { resolve: { conditions: [...conditions, "node", "development|production"] } };
+	return {
+		// Vitest loads the global setup in its own environment, which needs the application's conditions to find the generator's sources.
+		environments: { "__vitest__": server },
+		resolve: { conditions: [...conditions, "module", "browser", "development|production"] },
+		ssr: server,
+		test: {
+			...testProjects(options),
+			globalSetup: [fileURLToPath(import.meta.resolve("#adapters/vitest/setup.ts"))],
+			server: { deps: { inline: [/^@shivaedev\//u] } },
+		},
+	};
+}

package/src/adapters/appViteConfig.ts

@@ -0,0 +1,31 @@
+import type { PluginOption } from "vite";
+import { type BuildPluginOptions, buildPlugin } from "#adapters/vitePlugin.ts";
+import { vitePort } from "#adapters/vitePort.ts";
+
+export interface AppViteOptions extends BuildPluginOptions {
+	readonly apiPort?: number;
+	readonly webPort?: number;
+}
+
+export function appViteConfig(
+	plugins: PluginOption[],
+	conditions: string[] = [],
+	proxyPaths: string[] = [],
+	{ webPort = vitePort("VITE_PORT", 5173), apiPort = vitePort("PORT", 3000), ...build }: AppViteOptions = {},
+) {
+	return {
+		plugins: [...plugins, ...buildPlugin(build)],
+		resolve: { conditions, tsconfigPaths: true },
+		server: {
+			host: "127.0.0.1",
+			port: webPort,
+			proxy: Object.fromEntries(
+				["/api/auth", "/rpc", ...proxyPaths].map((path) => [
+					path,
+					{ changeOrigin: false, target: `http://127.0.0.1:${apiPort}`, ws: path === "/rpc" },
+				]),
+			),
+			strictPort: true,
+		},
+	};
+}

package/src/adapters/bundleCheck.ts

@@ -0,0 +1,57 @@
+import { isBuiltin } from "node:module";
+import { dirname, join } from "node:path";
+import { Option } from "effect";
+import type { Plugin, Rollup } from "vite";
+import { runNode } from "#adapters/runNode.ts";
+import { type BundleGraph, type BundleModule, type ServerMarkers, serverCodeIn } from "#serverCode.ts";
+
+const BROWSER_EXTERNAL = "__vite-browser-external:";
+
+function graphOf(context: Rollup.PluginContext): BundleGraph {
+	const modules = new Map<string, BundleModule>();
+	const entries: string[] = [];
+	for (const id of context.getModuleIds()) {
+		const info = context.getModuleInfo(id);
+		if (info !== null) {
+			if (info.isEntry) {
+				entries.push(id);
+			}
+			const bare = id.startsWith(BROWSER_EXTERNAL) ? id.slice(BROWSER_EXTERNAL.length) : id;
+			modules.set(id, { builtin: isBuiltin(bare), imports: [...info.importedIds, ...info.dynamicallyImportedIds] });
+		}
+	}
+	return { entries, modules };
+}
+
+async function markersFrom(context: Rollup.PluginContext, root: string): Promise<ServerMarkers> {
+	const importer = join(root, "index.html");
+	async function resolved(specifier: string) {
+		return Option.fromNullishOr((await context.resolve(specifier, importer))?.id);
+	}
+	return {
+		defineModule: await resolved("@shivaedev/contract/defineModule.ts"),
+		operation: await resolved("@shivaedev/contract/operation.ts"),
+		sql: Option.map(await resolved("effect/sql"), dirname),
+	};
+}
+
+export function bundleCheck(serverOnly: readonly string[]): Plugin {
+	let root = ".";
+	return {
+		apply: "build",
+		applyToEnvironment: (environment) => environment.config.consumer === "client",
+		async buildEnd(this: Rollup.PluginContext, error) {
+			if (error !== undefined) {
+				return;
+			}
+			const found = await runNode(serverCodeIn(graphOf(this), await markersFrom(this, root), { root, serverOnly }));
+			if (Option.isSome(found)) {
+				this.error(found.value);
+			}
+		},
+		configResolved(resolved) {
+			root = resolved.root;
+		},
+		name: "shivaedev:build-bundle-check",
+	};
+}

package/src/adapters/copiedCode.ts

@@ -0,0 +1,103 @@
+import ts from "typescript";
+import type { CodePart, ImportFact } from "#facts.ts";
+
+export interface Copying {
+	readonly checker: ts.TypeChecker;
+	// Names the copied part in a refusal, such as "notes.get reads".
+	readonly label: string;
+	readonly refuse: (message: string) => void;
+}
+
+const LOCAL_DECLARATIONS = new Set([
+	ts.SyntaxKind.VariableDeclaration,
+	ts.SyntaxKind.FunctionDeclaration,
+	ts.SyntaxKind.ClassDeclaration,
+	ts.SyntaxKind.InterfaceDeclaration,
+	ts.SyntaxKind.TypeAliasDeclaration,
+	ts.SyntaxKind.EnumDeclaration,
+	ts.SyntaxKind.ModuleDeclaration,
+	ts.SyntaxKind.Parameter,
+	ts.SyntaxKind.BindingElement,
+]);
+
+type ImportBinding = ts.ImportSpecifier | ts.ImportClause | ts.NamespaceImport;
+
+function importBinding(declaration: ts.Declaration): ImportBinding | undefined {
+	return ts.isImportSpecifier(declaration) || ts.isImportClause(declaration) || ts.isNamespaceImport(declaration) ? declaration : undefined;
+}
+
+function clauseOf(binding: ImportBinding): ts.ImportClause {
+	if (ts.isImportClause(binding)) {
+		return binding;
+	}
+	return ts.isNamespaceImport(binding) ? binding.parent : binding.parent.parent;
+}
+
+function importedName(binding: ImportBinding): string {
+	if (ts.isImportClause(binding)) {
+		return "default";
+	}
+	return ts.isNamespaceImport(binding) ? "*" : (binding.propertyName ?? binding.name).text;
+}
+
+function importFact(copying: Copying, binding: ImportBinding, local: string): ImportFact | undefined {
+	const clause = clauseOf(binding);
+	const declaration = clause.parent;
+	if (!ts.isStringLiteral(declaration.moduleSpecifier)) {
+		return undefined;
+	}
+	const specifier = declaration.moduleSpecifier.text;
+	const file = declaration.getSourceFile().fileName;
+	if (specifier.startsWith(".")) {
+		copying.refuse(
+			`${copying.label} imports ${local} by the relative path "${specifier}" in ${file}; import it through a package import, such as a # specifier, so the generated file can import it too`,
+		);
+		return undefined;
+	}
+	const name = importedName(binding);
+	const target = copying.checker.getSymbolAtLocation(declaration.moduleSpecifier)?.valueDeclaration?.getSourceFile().fileName;
+	const typeOnly = clause.isTypeOnly || (ts.isImportSpecifier(binding) && binding.isTypeOnly);
+	return { local, name, specifier, target, typeOnly, writtenIn: file };
+}
+
+function referenceOf(copying: Copying, node: ts.Node, identifier: ts.Identifier): ImportFact | "local" | undefined {
+	const symbol = ts.isShorthandPropertyAssignment(identifier.parent)
+		? copying.checker.getShorthandAssignmentValueSymbol(identifier.parent)
+		: copying.checker.getSymbolAtLocation(identifier);
+	const declaration = symbol?.declarations?.[0];
+	if (declaration === undefined) {
+		return undefined;
+	}
+	const binding = importBinding(declaration);
+	if (binding !== undefined) {
+		return importFact(copying, binding, identifier.text);
+	}
+	const inside = declaration.pos >= node.pos && declaration.end <= node.end;
+	const sameFile = declaration.getSourceFile() === node.getSourceFile();
+	return sameFile && !inside && LOCAL_DECLARATIONS.has(declaration.kind) ? "local" : undefined;
+}
+
+// The code as written, with each imported name kept as its import, so the generated file can import and rename it.
+export function copiedCode(copying: Copying, node: ts.Node): readonly CodePart[] {
+	const source = node.getSourceFile();
+	const parts: CodePart[] = [];
+	let position = node.getStart(source);
+	function visit(child: ts.Node) {
+		if (ts.isIdentifier(child)) {
+			const reference = referenceOf(copying, node, child);
+			if (reference === "local") {
+				copying.refuse(
+					`${copying.label} uses ${child.text}, which is declared in ${source.fileName}; move it to a module the operation imports it from, such as the module's model file`,
+				);
+			} else if (reference !== undefined) {
+				const shorthand = ts.isShorthandPropertyAssignment(child.parent) ? `${child.text}: ` : "";
+				parts.push(source.text.slice(position, child.getStart(source)) + shorthand, reference);
+				position = child.end;
+			}
+		}
+		ts.forEachChild(child, visit);
+	}
+	visit(node);
+	parts.push(source.text.slice(position, node.end));
+	return parts.filter((part) => part !== "");
+}

package/src/adapters/failuresOf.ts

@@ -0,0 +1,31 @@
+import ts from "typescript";
+import { declaredClass, isSchemaClass, type TypeReading } from "#adapters/typeReading.ts";
+import type { Failure } from "#facts.ts";
+
+function failureOf(reading: TypeReading, member: ts.Type): Failure | undefined {
+	if (member.flags & ts.TypeFlags.Never) {
+		return undefined;
+	}
+	if (member.getProperty("isRetryable") !== undefined) {
+		return { kind: "retryable" };
+	}
+	const text = reading.checker.typeToString(member);
+	const tagProperty = member.getProperty("_tag");
+	const tag = tagProperty === undefined ? undefined : reading.checker.getTypeOfSymbol(tagProperty);
+	if (tag === undefined || !tag.isStringLiteral()) {
+		return { kind: "untagged", text };
+	}
+	// Object.assign(new NoteChanged(...), { cause }) raises a NoteChanged whose type is an intersection.
+	const parts = member.isIntersection() ? member.types : [member];
+	const symbol = parts.map((part) => part.getSymbol()).find((candidate) => candidate !== undefined && candidate.flags & ts.SymbolFlags.Class);
+	const declared = symbol === undefined ? undefined : declaredClass(reading, symbol);
+	if (symbol === undefined || declared?.exportName === undefined) {
+		return { kind: "unexported", tag: tag.value, text };
+	}
+	return { declared, kind: "class", schema: isSchemaClass(reading, symbol), tag: tag.value };
+}
+
+// A rejection is the class run raises, so each failure keeps the declaration it came from, never just its shape.
+export function failuresOf(reading: TypeReading, errors: readonly ts.Type[]): readonly Failure[] {
+	return errors.flatMap((error) => (error.isUnion() ? error.types : [error])).flatMap((member) => failureOf(reading, member) ?? []);
+}

package/src/adapters/isReadonlyProperty.ts

@@ -0,0 +1,21 @@
+import ts from "typescript";
+
+// TypeScript 6 answers two questions only through internal API: whether a property is readonly (a mapped type such as
+// Readonly<T> or a Schema's Type marks it in internal flags, not on a declaration) and which optional properties exclude
+// undefined. The compiler-api catalog pins the version, so these stay put.
+declare module "typescript" {
+	function getCheckFlags(symbol: ts.Symbol): number;
+	function getDeclarationModifierFlagsFromSymbol(symbol: ts.Symbol): ts.ModifierFlags;
+	interface TypeChecker {
+		getExactOptionalProperties: (type: ts.Type) => ts.Symbol[];
+	}
+}
+
+const READONLY_CHECK_FLAG = 8;
+
+export function isReadonlyProperty(property: ts.Symbol): boolean {
+	return (
+		(ts.getCheckFlags(property) & READONLY_CHECK_FLAG) !== 0
+		|| ((property.flags & ts.SymbolFlags.Property) !== 0 && (ts.getDeclarationModifierFlagsFromSymbol(property) & ts.ModifierFlags.Readonly) !== 0)
+	);
+}

package/src/adapters/moduleCalls.ts

@@ -0,0 +1,58 @@
+import ts from "typescript";
+
+export interface ModuleCall {
+	readonly definition: ts.Expression | undefined;
+	readonly exported: boolean;
+	readonly variable: ts.VariableDeclaration;
+}
+
+function importsDefineModule(source: ts.SourceFile): ReadonlySet<string> {
+	const locals = new Set<string>();
+	for (const statement of source.statements) {
+		const bindings = ts.isImportDeclaration(statement) ? statement.importClause?.namedBindings : undefined;
+		if (bindings !== undefined && ts.isNamedImports(bindings)) {
+			for (const element of bindings.elements) {
+				if ((element.propertyName ?? element.name).text === "defineModule") {
+					locals.add(element.name.text);
+				}
+			}
+		}
+	}
+	return locals;
+}
+
+// Found by syntax alone, so discovery and the cache need no program.
+export function moduleCalls(source: ts.SourceFile): readonly ModuleCall[] {
+	const locals = importsDefineModule(source);
+	if (locals.size === 0) {
+		return [];
+	}
+	return source.statements.flatMap((statement) => {
+		if (!ts.isVariableStatement(statement)) {
+			return [];
+		}
+		const exported = statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) === true;
+		return statement.declarationList.declarations.flatMap((variable) => {
+			const call = variable.initializer;
+			return call !== undefined && ts.isCallExpression(call) && ts.isIdentifier(call.expression) && locals.has(call.expression.text)
+				? [{ definition: call.arguments[0], exported, variable }]
+				: [];
+		});
+	});
+}
+
+export function propertyOf(literal: ts.ObjectLiteralExpression, name: string): ts.ObjectLiteralElementLike | undefined {
+	return literal.properties.find(
+		(property) => property.name !== undefined && (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) && property.name.text === name,
+	);
+}
+
+export function initializerOf(property: ts.ObjectLiteralElementLike | undefined): ts.Expression | undefined {
+	if (property === undefined) {
+		return undefined;
+	}
+	if (ts.isPropertyAssignment(property)) {
+		return property.initializer;
+	}
+	return ts.isShorthandPropertyAssignment(property) ? property.name : undefined;
+}

package/src/adapters/moduleFacts.ts

@@ -0,0 +1,66 @@
+import ts from "typescript";
+import { copiedCode } from "#adapters/copiedCode.ts";
+import { initializerOf, moduleCalls, propertyOf } from "#adapters/moduleCalls.ts";
+import { operationFacts } from "#adapters/operationFacts.ts";
+import type { TypeReading } from "#adapters/typeReading.ts";
+import type { ModuleFacts } from "#facts.ts";
+
+function readingFor(program: ts.Program, refuse: (message: string) => void) {
+	const checker = program.getTypeChecker();
+	return (label: string): TypeReading => ({
+		checker,
+		program,
+		refuse: (type, path, instead) => {
+			refuse(`${label}: run returns ${checker.typeToString(type)} at ${path}, which has no exact wire form; ${instead}`);
+			return undefined;
+		},
+	});
+}
+
+export function moduleFacts(program: ts.Program, file: string): ModuleFacts {
+	// Creating the checker binds the files, which sets the parent links that reading a node's text needs.
+	const checker = program.getTypeChecker();
+	const refusals = new Set<string>();
+	function refuse(message: string) {
+		refusals.add(message);
+	}
+	const empty = { exportName: "", file, keyScope: undefined, middleware: undefined, name: "", operations: [], subject: undefined };
+	const source = program.getSourceFile(file);
+	const calls = source === undefined ? [] : moduleCalls(source);
+	const [call, ...others] = calls;
+	if (call === undefined || others.length > 0) {
+		return { ...empty, refusals: [`${file}: defines ${calls.length} modules; define exactly one module per file`] };
+	}
+	const definition = call.definition;
+	const nameValue = definition !== undefined && ts.isObjectLiteralExpression(definition) ? initializerOf(propertyOf(definition, "name")) : undefined;
+	if (definition === undefined || !ts.isObjectLiteralExpression(definition) || nameValue === undefined || !ts.isStringLiteral(nameValue)) {
+		return { ...empty, refusals: [`${file}: defineModule takes an object literal whose name is a string literal`] };
+	}
+	const name = nameValue.text;
+	const exportName = call.variable.name.getText();
+	if (!(call.exported && ts.isIdentifier(call.variable.name))) {
+		refuse(`${name}: export the module as a const, such as export const ${exportName} = defineModule(...)`);
+	}
+	const literal = definition;
+	function copy(field: string) {
+		const node = initializerOf(propertyOf(literal, field));
+		return node === undefined ? undefined : copiedCode({ checker, label: `${name} ${field}`, refuse }, node);
+	}
+	const list = initializerOf(propertyOf(definition, "operations"));
+	if (list === undefined || !ts.isArrayLiteralExpression(list)) {
+		refuse(`${name}: operations is an array literal of the module's operations`);
+	}
+	const reading = readingFor(program, refuse);
+	const elements = list !== undefined && ts.isArrayLiteralExpression(list) ? list.elements : [];
+	const operations = elements.flatMap((element) => operationFacts({ moduleName: name, reading, refuse }, element) ?? []);
+	return {
+		exportName,
+		file,
+		keyScope: copy("keyScope"),
+		middleware: copy("middleware"),
+		name,
+		operations,
+		refusals: [...refusals],
+		subject: copy("subject"),
+	};
+}

package/src/adapters/objectForm.ts

@@ -0,0 +1,74 @@
+import ts from "typescript";
+import { isReadonlyProperty } from "#adapters/isReadonlyProperty.ts";
+import { declaredClass, isSchemaClass, type TypeReading } from "#adapters/typeReading.ts";
+import { unionForm } from "#adapters/unionForm.ts";
+import type { Field, WireForm } from "#facts.ts";
+
+type Read = (type: ts.Type, path: string) => WireForm | undefined;
+
+export function classForm(reading: TypeReading, type: ts.Type, symbol: ts.Symbol, path: string): WireForm | undefined {
+	if (!isSchemaClass(reading, symbol)) {
+		return reading.refuse(type, path, "return a plain object, or make the class a Schema class");
+	}
+	const declared = declaredClass(reading, symbol);
+	if (declared?.exportName === undefined) {
+		return reading.refuse(type, path, `export the Schema class ${symbol.name} from its module`);
+	}
+	return { declared, form: "class" };
+}
+
+// An exact optional property's only undefined member is the one optionality adds: TypeScript merges a written undefined
+// into it, and the property is then not exact.
+function optionalForm(reading: TypeReading, type: ts.Type, path: string, read: Read): WireForm | undefined {
+	const members = type.isUnion() ? type.types.filter((member) => !(member.flags & ts.TypeFlags.Undefined)) : [type];
+	const [only] = members;
+	if (only === undefined) {
+		return reading.refuse(type, path, "give the optional property a type besides undefined, or drop it");
+	}
+	return members.length === 1 ? read(only, path) : unionForm(reading, type, members, path, read);
+}
+
+function fieldOf(reading: TypeReading, property: ts.Symbol, exact: ReadonlySet<ts.Symbol>, path: string, read: Read): Field | undefined {
+	const optional = (property.flags & ts.SymbolFlags.Optional) !== 0;
+	const type = reading.checker.getTypeOfSymbol(property);
+	if (optional && !exact.has(property)) {
+		return reading.refuse(type, path, `drop undefined from the optional property ${property.name}, so an absent key is the only way to leave it out`);
+	}
+	const form = optional ? optionalForm(reading, type, path, read) : read(type, path);
+	return form === undefined ? undefined : { form, mutable: !isReadonlyProperty(property), name: property.name, optional };
+}
+
+function recordForm(reading: TypeReading, type: ts.Type, path: string, read: Read): WireForm | undefined {
+	const [index, ...others] = reading.checker.getIndexInfosOfType(type);
+	if (index === undefined || others.length > 0 || !(index.keyType.flags & ts.TypeFlags.String)) {
+		return reading.refuse(type, path, "use string keys only");
+	}
+	const value = read(index.type, `${path}[string]`);
+	return value === undefined ? undefined : { form: "record", mutable: !index.isReadonly, value };
+}
+
+export function objectForm(reading: TypeReading, type: ts.Type, path: string, read: Read): WireForm | undefined {
+	if (type.getCallSignatures().length > 0 || type.getConstructSignatures().length > 0) {
+		return reading.refuse(type, path, "return data, not a function");
+	}
+	const symbol = type.getSymbol();
+	const builtIn =
+		symbol !== undefined
+		&& symbol.flags & ts.SymbolFlags.Interface
+		&& symbol.declarations?.some((declaration) => reading.program.isSourceFileDefaultLibrary(declaration.getSourceFile()));
+	if (builtIn === true) {
+		return reading.refuse(type, path, "return a plain object, an array or a string-keyed record");
+	}
+	const properties = reading.checker.getPropertiesOfType(type);
+	const indexes = reading.checker.getIndexInfosOfType(type);
+	if (indexes.length > 0) {
+		return properties.length === 0 ? recordForm(reading, type, path, read) : reading.refuse(type, path, "use either fixed properties or a record");
+	}
+	const methods = properties.filter((property) => reading.checker.getTypeOfSymbol(property).getCallSignatures().length > 0);
+	if (methods.length > 0 || properties.some((property) => property.name.startsWith("__@"))) {
+		return reading.refuse(type, path, "return plain data, without methods or symbol keys");
+	}
+	const exact = new Set(reading.checker.getExactOptionalProperties(type));
+	const fields = properties.map((property) => fieldOf(reading, property, exact, `${path}.${property.name}`, read));
+	return fields.every((field) => field !== undefined) ? { fields, form: "struct" } : undefined;
+}