@shivaedev/build 0.0.0 → 0.1.1

package/src/cache.ts

@@ -0,0 +1,28 @@
+import { Effect, Option, Path, Schema } from "effect";
+import { readIfPresent, writeAtomically } from "#files.ts";
+
+const CacheRecord = Schema.Struct({ content: Schema.String, key: Schema.String });
+
+const CacheJson = Schema.fromJsonString(CacheRecord);
+
+const decodeRecord = Schema.decodeUnknownOption(CacheJson);
+
+const encodeRecord = Schema.encodeEffect(CacheJson);
+
+const recordPath = Effect.fn("Build.recordPath")(function* (root: string, module: string) {
+	const path = yield* Path.Path;
+	return path.join(root, "node_modules", ".cache", "@shivaedev", "build", `${path.relative(root, module)}.json`);
+});
+
+// The output of the last run whose inputs had this key; another key, or an unreadable record, means the module must be derived.
+export const cachedOutput = Effect.fn("Build.cachedOutput")(function* (root: string, module: string, key: string) {
+	const text = yield* readIfPresent(yield* recordPath(root, module));
+	return Option.filter(
+		Option.flatMap(text, (json) => decodeRecord(json)),
+		(record) => record.key === key,
+	).pipe(Option.map((record) => record.content));
+});
+
+export const recordOutput = Effect.fn("Build.recordOutput")(function* (root: string, module: string, key: string, content: string) {
+	yield* writeAtomically(yield* recordPath(root, module), yield* encodeRecord({ content, key }));
+});

package/src/cli.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { Cause, Console, Effect } from "effect";
+import { CliError, Command } from "effect/cli";
+import { buildCommand } from "#command.ts";
+import packageInfo from "#package.json" with { type: "json" };
+
+const main = Command.run(buildCommand, { version: packageInfo.version }).pipe(
+	Effect.tapError((error) => (CliError.isCliError(error) || error._tag === "GenerateFailed" ? Effect.void : Console.error(error.message))),
+	Effect.tapCause((cause) => (Cause.hasDies(cause) ? Console.error(Cause.pretty(cause)) : Effect.void)),
+	Effect.provide([NodeServices.layer, NodeCrypto.layer]),
+);
+
+NodeRuntime.runMain(main, { disableErrorReporting: true });

package/src/code.ts

@@ -0,0 +1,23 @@
+// An import the generated file needs; the file gives each distinct one a local name and writes the import once.
+export interface ImportRef {
+	readonly name: string;
+	readonly preferred: string;
+	readonly specifier: string;
+	readonly typeOnly: boolean;
+}
+
+export type Code = readonly (string | ImportRef)[];
+
+export const SCHEMA: ImportRef = { name: "Schema", preferred: "Schema", specifier: "effect", typeOnly: false };
+
+function isCode(part: string | ImportRef | Code): part is Code {
+	return Array.isArray(part);
+}
+
+export function code(...parts: readonly (string | ImportRef | Code)[]): Code {
+	return parts.flatMap((part) => (isCode(part) ? part : [part]));
+}
+
+export function joined(items: readonly Code[], separator: string): Code {
+	return items.flatMap((item, index) => (index === 0 ? item : [separator, ...item]));
+}

package/src/command.ts

@@ -0,0 +1,42 @@
+import { Console, Effect, Path } from "effect";
+import { Command, Flag } from "effect/cli";
+import { generate } from "#generate.ts";
+import type { GenerateReport, ModuleStatus } from "#report.ts";
+
+const WORDS: Readonly<Record<ModuleStatus, string>> = {
+	current: "current",
+	missing: "missing",
+	orphaned: "orphaned, its module is gone",
+	refused: "refused",
+	removed: "removed, its module is gone",
+	stale: "stale",
+	unchanged: "unchanged, from the cache",
+	written: "written",
+};
+
+const printReport = Effect.fn("Build.printReport")(function* (report: GenerateReport) {
+	for (const { output, status } of report.modules) {
+		yield* Console.log(`${output}: ${WORDS[status]}`);
+	}
+	if (report.modules.length === 0) {
+		yield* Console.log("No file of the project calls defineModule.");
+	}
+});
+
+export const generateCommand = Command.make("generate", { check: Flag.Boolean("check").pipe(Flag.withDefault(false)) }, ({ check }) =>
+	Effect.gen(function* () {
+		const path = yield* Path.Path;
+		const report = yield* generate(path.resolve(), { check }).pipe(
+			Effect.tapErrorTag("GenerateFailed", (failed) =>
+				printReport(failed.report).pipe(Effect.andThen(Effect.forEach(failed.problems, (problem) => Console.error(problem)))),
+			),
+		);
+		yield* printReport(report);
+	}),
+).pipe(
+	Command.withDescription(
+		"Write src/generated/<module>.ts for every defineModule call of the project in the current directory and remove each generated file whose module is gone; --check writes nothing and fails on a missing, stale or orphaned file",
+	),
+);
+
+export const buildCommand = Command.make("shivaedev-build").pipe(Command.withSubcommands([generateCommand]));

package/src/emit.ts

@@ -0,0 +1,117 @@
+import { type Code, code, type ImportRef, joined } from "#code.ts";
+import { importNames } from "#importNames.ts";
+
+export interface PlannedOperation {
+	readonly kind: "command" | "query";
+	readonly members: readonly Code[];
+	readonly name: string;
+	readonly payload: Code | undefined;
+	readonly rejections: readonly (readonly [string, ImportRef])[];
+	readonly success: Code;
+}
+
+export interface PlannedModule {
+	readonly exportName: string;
+	readonly keyScope: Code | undefined;
+	readonly middleware: Code | undefined;
+	readonly module: ImportRef;
+	readonly name: string;
+	readonly operations: readonly PlannedOperation[];
+	readonly source: string;
+	readonly subject: Code | undefined;
+}
+
+const CLIENT_CONTRACT: ImportRef = {
+	name: "clientContract",
+	preferred: "clientContract",
+	specifier: "@shivaedev/contract/clientContract.ts",
+	typeOnly: false,
+};
+const MATCHES: ImportRef = {
+	name: "ClientMatchesModule",
+	preferred: "ClientMatchesModule",
+	specifier: "@shivaedev/contract/clientMatchesModule.ts",
+	typeOnly: true,
+};
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/u;
+const HEADER = /^\/\/ Generated by @shivaedev\/build from (?<source>.+)\. Do not edit or commit this file; run `pnpm generate` to write it again\.$/u;
+
+function headerOf(source: string): string {
+	return `// Generated by @shivaedev/build from ${source}. Do not edit or commit this file; run \`pnpm generate\` to write it again.`;
+}
+
+// The module a file was generated from, read from its first line, so generate tells its own files from others under src/generated.
+export function generatedFrom(text: string): string | undefined {
+	return HEADER.exec(text.split("\n", 1)[0] ?? "")?.groups?.source;
+}
+
+function keyOf(name: string): string {
+	return IDENTIFIER.test(name) ? name : JSON.stringify(name);
+}
+
+export function identifierOf(name: string): string {
+	const words = name.split(/[^A-Za-z0-9_$]+/u).filter((word) => word !== "");
+	const camel = words.map((word, index) => (index === 0 ? word : `${word.charAt(0).toUpperCase()}${word.slice(1)}`)).join("");
+	return /^[0-9]/u.test(camel) || camel === "" ? `_${camel}` : camel;
+}
+
+function entries(lines: readonly Code[]): Code {
+	return code("{\n", ...lines.map((line) => code("\t\t", line, ",\n")), "\t}");
+}
+
+function field(name: string, value: Code | undefined): readonly Code[] {
+	return value === undefined ? [] : [code(`\t${name}: `, value, ",\n")];
+}
+
+export function emit(planned: PlannedModule): string {
+	const operations = planned.operations;
+	const base = identifierOf(planned.name);
+	const wireName = `${base}Wire`;
+	const matchName = `${base}MatchModule`;
+	const moduleType = { ...planned.module, preferred: `${planned.exportName}Module` };
+	function client(kind: PlannedOperation["kind"]) {
+		const chosen = operations.filter((operation) => operation.kind === kind);
+		return chosen.length === 0
+			? undefined
+			: entries(
+					chosen.map((operation) =>
+						operation.members.length === 0
+							? code(`${keyOf(operation.name)}: {}`)
+							: code(`${keyOf(operation.name)}: { `, joined(operation.members, ", "), " }"),
+					),
+				);
+	}
+	const payloads = operations.flatMap((operation) =>
+		operation.payload === undefined ? [] : [code(`${keyOf(operation.name)}: `, operation.payload)],
+	);
+	const contract = code(
+		...field("commands", client("command")),
+		...field("keyScope", planned.keyScope),
+		...field("middleware", planned.middleware),
+		`\tname: ${JSON.stringify(planned.name)},\n`,
+		...field("payloads", payloads.length === 0 ? undefined : entries(payloads)),
+		...field("queries", client("query")),
+		...field("subject", planned.subject),
+		`\twire: ${wireName},\n`,
+	);
+	const all = code(
+		contract,
+		CLIENT_CONTRACT,
+		MATCHES,
+		moduleType,
+		...operations.flatMap((operation) => [operation.success, ...operation.rejections.map(([, ref]) => ref)]),
+	);
+	const names = importNames(all, new Set([wireName, matchName, planned.exportName]));
+	const wire = operations.map((operation) => {
+		const rejections = operation.rejections.map(([tag, ref]) => (names.local(ref) === tag ? tag : `${keyOf(tag)}: ${names.local(ref)}`));
+		const listed = rejections.length === 0 ? "{}" : `{ ${rejections.join(", ")} }`;
+		return `\t${keyOf(operation.name)}: { rejections: ${listed}, success: ${names.text(operation.success)} },\n`;
+	});
+	return [
+		`${headerOf(planned.source)}\n`,
+		...names.lines.map((line) => `${line}\n`),
+		`\nexport const ${wireName} = {\n${wire.join("")}} as const;\n`,
+		`\nexport const ${planned.exportName} = ${names.local(CLIENT_CONTRACT)}({\n${names.text(contract)}});\n`,
+		`\nexport const ${matchName}: ${names.local(MATCHES)}<typeof ${planned.exportName}, typeof ${names.local(moduleType)}> = true;\n`,
+	].join("");
+}

package/src/facts.ts

@@ -0,0 +1,70 @@
+// What the type checker says about a module, as plain data: the adapter reads it from a program, the core decides from it.
+
+export interface ImportFact {
+	readonly local: string;
+	readonly name: string;
+	readonly specifier: string;
+	// The file the import resolves to, so a specifier written in another package can be rewritten for the project.
+	readonly target: string | undefined;
+	readonly typeOnly: boolean;
+	readonly writtenIn: string;
+}
+
+export type CodePart = string | ImportFact;
+
+export interface DeclaredClass {
+	readonly className: string;
+	readonly exportName: string | undefined;
+	readonly file: string;
+}
+
+export type Literal = string | number | boolean;
+
+export type Primitive = "BigInt" | "Boolean" | "Date" | "DateTimeUtc" | "Null" | "Number" | "String" | "Undefined" | "Void";
+
+export interface Field {
+	readonly form: WireForm;
+	readonly mutable: boolean;
+	readonly name: string;
+	readonly optional: boolean;
+}
+
+export type WireForm =
+	| { readonly form: "primitive"; readonly primitive: Primitive }
+	| { readonly form: "literals"; readonly values: readonly Literal[] }
+	| { readonly form: "array"; readonly item: WireForm; readonly mutable: boolean }
+	| { readonly form: "tuple"; readonly elements: readonly WireForm[]; readonly mutable: boolean }
+	| { readonly form: "struct"; readonly fields: readonly Field[] }
+	| { readonly form: "record"; readonly value: WireForm; readonly mutable: boolean }
+	| { readonly form: "union"; readonly members: readonly WireForm[] }
+	| { readonly form: "nullOr"; readonly inner: WireForm }
+	| { readonly form: "option"; readonly inner: WireForm }
+	| { readonly form: "class"; readonly declared: DeclaredClass };
+
+export type Failure =
+	| { readonly kind: "retryable" }
+	| { readonly kind: "class"; readonly declared: DeclaredClass; readonly schema: boolean; readonly tag: string }
+	| { readonly kind: "unexported"; readonly tag: string; readonly text: string }
+	| { readonly kind: "untagged"; readonly text: string };
+
+export interface OperationFacts {
+	readonly failures: readonly Failure[];
+	readonly invalidates: readonly CodePart[] | undefined;
+	readonly kind: "command" | "query";
+	readonly name: string;
+	readonly payload: readonly CodePart[] | undefined;
+	readonly reads: readonly CodePart[] | undefined;
+	readonly readsCollections: readonly CodePart[] | undefined;
+	readonly success: WireForm | undefined;
+}
+
+export interface ModuleFacts {
+	readonly exportName: string;
+	readonly file: string;
+	readonly keyScope: readonly CodePart[] | undefined;
+	readonly middleware: readonly CodePart[] | undefined;
+	readonly name: string;
+	readonly operations: readonly OperationFacts[];
+	readonly refusals: readonly string[];
+	readonly subject: readonly CodePart[] | undefined;
+}

package/src/files.ts

@@ -0,0 +1,24 @@
+import { Effect, FileSystem, Option, Path } from "effect";
+
+export const readIfPresent = Effect.fn("Build.readIfPresent")(function* (file: string) {
+	const fs = yield* FileSystem.FileSystem;
+	return yield* fs.readFileString(file).pipe(
+		Effect.map(Option.some),
+		Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(Option.none<string>())),
+	);
+});
+
+// A reader never sees half a file: the text goes to a fresh file beside the target, which then replaces it in one rename. The
+// draft lives in a temporary folder of its own, removed when the write ends however it ends.
+export const writeAtomically = Effect.fn("Build.writeAtomically")(function* (file: string, text: string) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	yield* fs.makeDirectory(path.dirname(file), { recursive: true });
+	yield* Effect.scoped(
+		Effect.gen(function* () {
+			const draft = yield* fs.makeTempFileScoped({ directory: path.dirname(file), prefix: `.${path.basename(file)}.` });
+			yield* fs.writeFileString(draft, text);
+			yield* fs.rename(draft, file);
+		}),
+	);
+});

package/src/formCode.ts

@@ -0,0 +1,59 @@
+import { type Code, code, type ImportRef, joined, SCHEMA } from "#code.ts";
+import type { Field, WireForm } from "#facts.ts";
+
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/u;
+
+function schema(member: string, ...inner: readonly (string | ImportRef | Code)[]): Code {
+	return inner.length === 0 ? code(SCHEMA, `.${member}`) : code(SCHEMA, `.${member}(`, ...inner, ")");
+}
+
+function mutableWhen(mutable: boolean, inner: Code): Code {
+	return mutable ? schema("mutable", inner) : inner;
+}
+
+function fieldCode(field: Field, classRef: (form: Extract<WireForm, { form: "class" }>) => ImportRef): Code {
+	const value = formCode(field.form, classRef);
+	const optional = field.optional ? schema("optionalKey", value) : value;
+	const key = IDENTIFIER.test(field.name) ? field.name : JSON.stringify(field.name);
+	return code(`${key}: `, field.mutable ? schema("mutableKey", optional) : optional);
+}
+
+export function formCode(form: WireForm, classRef: (form: Extract<WireForm, { form: "class" }>) => ImportRef): Code {
+	function inner(each: WireForm) {
+		return formCode(each, classRef);
+	}
+	switch (form.form) {
+		case "primitive":
+			return schema(form.primitive);
+		case "literals":
+			return form.values.length === 1
+				? schema("Literal", JSON.stringify(form.values[0]))
+				: schema("Literals", `[${form.values.map((value) => JSON.stringify(value)).join(", ")}]`);
+		case "array":
+			return mutableWhen(form.mutable, schema("Array", inner(form.item)));
+		case "tuple":
+			return mutableWhen(form.mutable, schema("Tuple", "[", joined(form.elements.map(inner), ", "), "]"));
+		case "struct":
+			return form.fields.length === 0
+				? schema("Struct", "{}")
+				: schema(
+						"Struct",
+						"{ ",
+						joined(
+							form.fields.map((field) => fieldCode(field, classRef)),
+							", ",
+						),
+						" }",
+					);
+		case "record":
+			return schema("Record", schema("String"), ", ", form.mutable ? schema("mutableKey", inner(form.value)) : inner(form.value));
+		case "union":
+			return schema("Union", "[", joined(form.members.map(inner), ", "), "]");
+		case "nullOr":
+			return schema("NullOr", inner(form.inner));
+		case "option":
+			return schema("Option", inner(form.inner));
+		case "class":
+			return code(classRef(form));
+	}
+}

package/src/generate.ts

@@ -0,0 +1,86 @@
+import { Effect, Option, Path } from "effect";
+import { withHeavyLock } from "@shivaedev/heavy-lock/withHeavyLock.ts";
+import { deriveModules } from "#adapters/typeScript.ts";
+import { byText } from "#byText.ts";
+import { cachedOutput, recordOutput } from "#cache.ts";
+import { emit } from "#emit.ts";
+import { readIfPresent, writeAtomically } from "#files.ts";
+import { inputKey } from "#inputs.ts";
+import { plan } from "#plan.ts";
+import { moduleFiles, openProject } from "#project.ts";
+import { GenerateFailed, type GenerateReport, type ModuleOutcome, problemOf } from "#report.ts";
+import { settleOrphans } from "#settleOrphans.ts";
+
+export interface GenerateOptions {
+	// Writes nothing and fails when a generated file is missing or differs from what generate would write.
+	readonly check: boolean;
+}
+
+const settle = Effect.fn("Build.settle")(function* (options: GenerateOptions, output: string, content: string, fromCache: boolean) {
+	const existing = yield* readIfPresent(output);
+	if (Option.contains(existing, content)) {
+		return fromCache ? "unchanged" : "current";
+	}
+	if (options.check) {
+		return Option.isNone(existing) ? "missing" : "stale";
+	}
+	yield* writeAtomically(output, content);
+	return "written";
+});
+
+export const generate = Effect.fn("Build.generate")(function* (directory: string, options: GenerateOptions) {
+	const path = yield* Path.Path;
+	const project = yield* openProject(directory);
+	const files = yield* moduleFiles(project);
+	const refusals = files.flatMap(({ module, underSource }) =>
+		underSource
+			? []
+			: [
+					`${path.relative(project.root, module)}: defines a module outside src; move it under src, since its generated file goes to src/generated/<its path under src>`,
+				],
+	);
+	const placed = files.filter(({ underSource }) => underSource);
+	const keyed = yield* Effect.forEach(placed, (file) =>
+		Effect.gen(function* () {
+			const { files: inputs, key } = yield* inputKey(project, file.module);
+			return { ...file, cached: yield* cachedOutput(project.root, file.module, key), inputs, key };
+		}),
+	);
+	const pending = keyed.filter(({ cached }) => Option.isNone(cached));
+	const facts =
+		pending.length === 0
+			? []
+			: yield* withHeavyLock(
+					deriveModules(
+						project.config,
+						pending.map(({ module }) => module),
+					),
+					{ command: "shivaedev-build generate" },
+				);
+	const outcomes: ModuleOutcome[] = [];
+	for (const file of keyed) {
+		const relative = { module: path.relative(project.root, file.module), output: path.relative(project.root, file.output) };
+		const derived = facts.find((each) => each.file === file.module);
+		const planned = derived === undefined ? undefined : yield* plan({ output: file.output, root: project.root }, derived);
+		if (planned !== undefined && planned.refusals.length > 0) {
+			refusals.push(...planned.refusals);
+			outcomes.push({ ...relative, status: "refused" });
+			continue;
+		}
+		const content = Option.getOrElse(file.cached, () => (planned === undefined ? "" : emit(planned.planned)));
+		const status = yield* settle(options, file.output, content, Option.isSome(file.cached));
+		if (!options.check && Option.isNone(file.cached)) {
+			yield* recordOutput(project.root, file.module, file.key, content);
+		}
+		outcomes.push({ ...relative, status });
+	}
+	outcomes.push(...(yield* settleOrphans(project, options.check)));
+	const inputs = [...new Set(keyed.flatMap((file) => file.inputs))].sort(byText);
+	const report: GenerateReport = { inputs, modules: outcomes, programBuilt: pending.length > 0 };
+	const lines = outcomes.flatMap((outcome) => problemOf(outcome) ?? []);
+	if (refusals.length > 0 || lines.length > 0) {
+		const problems = [...refusals, ...lines].map((problem) => problem.replaceAll(`${project.root}${path.sep}`, ""));
+		return yield* new GenerateFailed({ problems, report });
+	}
+	return report;
+});

package/src/generateRound.ts

@@ -0,0 +1,60 @@
+import { Effect, FileSystem, Option, Path, Ref, Semaphore } from "effect";
+import { definesModule } from "#adapters/typeScript.ts";
+import { readIfPresent } from "#files.ts";
+import { generate } from "#generate.ts";
+import type { GenerateReport } from "#report.ts";
+
+export interface GenerateRound {
+	readonly changed: readonly string[];
+	readonly inputs: readonly string[];
+	readonly outputs: readonly string[];
+	// The generator's message when it refused a module; the refused module's file is left as it was.
+	readonly refusal: Option.Option<string>;
+}
+
+const roundOf = Effect.fn("Build.roundOf")(function* (root: string, report: GenerateReport, refusal: Option.Option<string>) {
+	const path = yield* Path.Path;
+	const round: GenerateRound = {
+		changed: report.modules.filter(({ status }) => status === "written" || status === "removed").map(({ output }) => path.join(root, output)),
+		inputs: report.inputs,
+		outputs: report.modules.map(({ output }) => path.join(root, output)),
+		refusal,
+	};
+	return round;
+});
+
+export const generateRound = Effect.fn("Build.generateRound")(function* (directory: string) {
+	const fs = yield* FileSystem.FileSystem;
+	const root = yield* fs.realPath(directory);
+	return yield* generate(root, { check: false }).pipe(
+		Effect.flatMap((report) => roundOf(root, report, Option.none())),
+		Effect.catchTag("GenerateFailed", (failed) => roundOf(root, failed.report, Option.some(failed.problems.join("\n")))),
+	);
+});
+
+// A dev server's generator: one run at a time, and a changed file starts a run only when some module's last run read it or it
+// is a module file under src that no run has seen yet.
+export const watchedGeneration = Effect.fn("Build.watchedGeneration")(function* (directory: string) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const root = yield* fs.realPath(directory);
+	const sources = `${path.join(root, "src")}${path.sep}`;
+	const generated = `${path.join(sources, "generated")}${path.sep}`;
+	const inputs = yield* Ref.make<ReadonlySet<string>>(new Set());
+	const serial = yield* Semaphore.make(1);
+	const run = serial.withPermits(1)(Effect.tap(generateRound(root), (round) => Ref.set(inputs, new Set(round.inputs))));
+	const newModule = Effect.fn("Build.newModule")(function* (file: string) {
+		if (!(file.startsWith(sources) && (file.endsWith(".ts") || file.endsWith(".tsx"))) || file.startsWith(generated)) {
+			return false;
+		}
+		return Option.exists(yield* readIfPresent(file), (text) => definesModule(file, text));
+	});
+	const changed = Effect.fn("Build.changed")(function* (file: string) {
+		const real = yield* fs.realPath(file).pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(file)));
+		const known = (yield* Ref.get(inputs)).has(real);
+		return known || (yield* newModule(real)) ? Option.some(yield* run) : Option.none<GenerateRound>();
+	});
+	return { changed, run };
+});
+
+export type WatchedGeneration = Effect.Success<ReturnType<typeof watchedGeneration>>;

package/src/importNames.ts

@@ -0,0 +1,61 @@
+import { byText } from "#byText.ts";
+import type { Code, ImportRef } from "#code.ts";
+
+function keyOf(ref: ImportRef): string {
+	return `${ref.specifier}\u0000${ref.name}`;
+}
+
+function sorted(values: readonly string[]): readonly string[] {
+	return [...values].sort(byText);
+}
+
+function importLine(specifier: string, entries: readonly (readonly [ImportRef, string, boolean])[]): readonly string[] {
+	const named = entries.filter(([ref]) => ref.name !== "*" && ref.name !== "default");
+	const whole = entries.filter(([ref]) => ref.name === "*" || ref.name === "default");
+	const allTypes = named.every(([, , typeOnly]) => typeOnly);
+	const names = named.map(([ref, local, typeOnly]) => {
+		const renamed = ref.name === local ? local : `${ref.name} as ${local}`;
+		return typeOnly && !allTypes ? `type ${renamed}` : renamed;
+	});
+	return [
+		...(named.length === 0 ? [] : [`import ${allTypes ? "type " : ""}{ ${sorted(names).join(", ")} } from "${specifier}";`]),
+		...whole.map(([ref, local, typeOnly]) => `import ${typeOnly ? "type " : ""}${ref.name === "*" ? `* as ${local}` : local} from "${specifier}";`),
+	];
+}
+
+// Gives every distinct import one local name, so two classes both called NotFound from different files both fit.
+export function importNames(code: Code, reserved: ReadonlySet<string>) {
+	const refs = new Map<string, ImportRef[]>();
+	for (const part of code) {
+		if (typeof part !== "string") {
+			refs.set(keyOf(part), [...(refs.get(keyOf(part)) ?? []), part]);
+		}
+	}
+	const taken = new Set(reserved);
+	const locals = new Map<string, string>();
+	for (const key of sorted([...refs.keys()])) {
+		const preferred = sorted((refs.get(key) ?? []).map((ref) => ref.preferred))[0] ?? "imported";
+		let chosen = preferred;
+		for (let suffix = 2; taken.has(chosen); suffix += 1) {
+			chosen = `${preferred}${suffix}`;
+		}
+		taken.add(chosen);
+		locals.set(key, chosen);
+	}
+	const bySpecifier = new Map<string, (readonly [ImportRef, string, boolean])[]>();
+	for (const [key, uses] of refs) {
+		const [first] = uses;
+		if (first !== undefined) {
+			const entry = [first, locals.get(key) ?? first.preferred, uses.every((use) => use.typeOnly)] as const;
+			bySpecifier.set(first.specifier, [...(bySpecifier.get(first.specifier) ?? []), entry]);
+		}
+	}
+	function local(ref: ImportRef) {
+		return locals.get(keyOf(ref)) ?? ref.preferred;
+	}
+	return {
+		lines: sorted([...bySpecifier.keys()]).flatMap((specifier) => importLine(specifier, bySpecifier.get(specifier) ?? [])),
+		local,
+		text: (written: Code) => written.map((part) => (typeof part === "string" ? part : local(part))).join(""),
+	};
+}