@hatchingpoint/point 0.0.3

package/src/core/cli.ts

@@ -0,0 +1,204 @@
+import { dirname, resolve } from "node:path";
+import { checkPointCore } from "./check.ts";
+import { createPointCoreIndex, createPointCoreRepairPlan, explainPointCoreRef } from "./context.ts";
+import { emitPointCoreTypeScript } from "./emit-typescript.ts";
+import { formatPointCore } from "./format.ts";
+import { parsePointCore } from "./parser.ts";
+
+const DEFAULT_INPUT = "examples/math.point";
+const DEFAULT_OUTPUT = "generated/math.ast.json";
+const DEFAULT_TS_OUTPUT = "generated/math.ts";
+const DEFAULT_PATTERN = "examples/**/*.point";
+const GENERATED_DIR = "generated";
+
+export async function main() {
+	const [, , command = "check", input = DEFAULT_INPUT, output = DEFAULT_OUTPUT] = Bun.argv;
+	if (command.endsWith("-all")) {
+		await runProjectCommand(command);
+		return;
+	}
+
+	const inputPath = resolve(process.cwd(), input);
+	const source = await Bun.file(inputPath).text();
+	const program = parsePointCore(source);
+	const diagnostics = checkPointCore(program);
+
+	if (command === "fmt") {
+		await Bun.write(inputPath, formatPointCore(program));
+		console.log(`Point core fmt wrote ${input}`);
+		return;
+	}
+
+	if (command === "fmt-check") {
+		const formatted = formatPointCore(program);
+		if (source !== formatted) {
+			console.error(`Point core fmt check failed: ${input}`);
+			process.exit(1);
+		}
+		console.log(`Point core fmt check passed: ${input}`);
+		return;
+	}
+
+	if (command === "check") {
+		if (diagnostics.length > 0) {
+			console.error(JSON.stringify({ ok: false, diagnostics }, null, 2));
+			process.exit(1);
+		}
+		console.log(`Point core check passed: ${input}`);
+		return;
+	}
+
+	if (command === "check-json") {
+		console.log(JSON.stringify({ schemaVersion: "point.core.check.v1", ok: diagnostics.length === 0, diagnostics }, null, 2));
+		if (diagnostics.length > 0) process.exit(1);
+		return;
+	}
+
+	if (command === "index") {
+		console.log(JSON.stringify(createPointCoreIndex(program), null, 2));
+		return;
+	}
+
+	if (command === "explain") {
+		const ref = output;
+		console.log(JSON.stringify(explainPointCoreRef(program, ref), null, 2));
+		return;
+	}
+
+	if (command === "repair-plan") {
+		console.log(JSON.stringify(createPointCoreRepairPlan(diagnostics), null, 2));
+		if (diagnostics.length > 0) process.exit(1);
+		return;
+	}
+
+	if (command === "print-ast") {
+		console.log(JSON.stringify(program, null, 2));
+		return;
+	}
+
+	if (command === "build") {
+		if (diagnostics.length > 0) {
+			console.error(JSON.stringify({ ok: false, diagnostics }, null, 2));
+			process.exit(1);
+		}
+		const outputPath = resolve(process.cwd(), output);
+		await Bun.$`mkdir -p ${dirname(outputPath)}`.quiet();
+		await Bun.write(outputPath, `${JSON.stringify(program, null, 2)}\n`);
+		console.log(`Point core build wrote ${output}`);
+		return;
+	}
+
+	if (command === "build-ts") {
+		if (diagnostics.length > 0) {
+			console.error(JSON.stringify({ ok: false, diagnostics }, null, 2));
+			process.exit(1);
+		}
+		const outputPath = resolve(process.cwd(), output === DEFAULT_OUTPUT ? DEFAULT_TS_OUTPUT : output);
+		await Bun.$`mkdir -p ${dirname(outputPath)}`.quiet();
+		await Bun.write(outputPath, emitPointCoreTypeScript(program));
+		console.log(`Point core TypeScript build wrote ${outputPath.replaceAll("\\", "/")}`);
+		return;
+	}
+
+	throw new Error(`Unknown point core command: ${command}`);
+}
+
+async function runProjectCommand(command: string) {
+	const inputs = await discoverInputs();
+	if (inputs.length === 0) throw new Error(`No Point core files matched ${DEFAULT_PATTERN}`);
+	const results = await Promise.all(inputs.map((input) => loadCoreFile(input)));
+
+	if (command === "fmt-all") {
+		await Promise.all(
+			results.map((result) =>
+				Bun.write(resolve(process.cwd(), result.input), formatPointCore(result.program)),
+			),
+		);
+		console.log(`Point core fmt wrote ${results.length} files`);
+		return;
+	}
+
+	if (command === "fmt-check-all") {
+		const unformatted = results.filter((result) => result.source !== formatPointCore(result.program));
+		if (unformatted.length > 0) {
+			console.error(JSON.stringify({ ok: false, unformatted: unformatted.map((result) => result.input) }, null, 2));
+			process.exit(1);
+		}
+		console.log(`Point core fmt check passed: ${results.length} files`);
+		return;
+	}
+
+	if (command === "check-all") {
+		const diagnostics = results.flatMap((result) =>
+			checkPointCore(result.program).map((diagnostic) => ({ ...diagnostic, file: result.input })),
+		);
+		if (diagnostics.length > 0) {
+			console.error(JSON.stringify({ ok: false, diagnostics }, null, 2));
+			process.exit(1);
+		}
+		console.log(`Point core check passed: ${results.length} files`);
+		return;
+	}
+
+	if (command === "build-all") {
+		const diagnostics = results.flatMap((result) =>
+			checkPointCore(result.program).map((diagnostic) => ({ ...diagnostic, file: result.input })),
+		);
+		if (diagnostics.length > 0) {
+			console.error(JSON.stringify({ ok: false, diagnostics }, null, 2));
+			process.exit(1);
+		}
+		for (const result of results) {
+			const output = outputFor(result.input);
+			const outputPath = resolve(process.cwd(), output);
+			await Bun.$`mkdir -p ${dirname(outputPath)}`.quiet();
+			await Bun.write(outputPath, `${JSON.stringify(result.program, null, 2)}\n`);
+		}
+		console.log(`Point core build wrote ${results.length} files`);
+		return;
+	}
+
+	if (command === "build-ts-all") {
+		const diagnostics = results.flatMap((result) =>
+			checkPointCore(result.program).map((diagnostic) => ({ ...diagnostic, file: result.input })),
+		);
+		if (diagnostics.length > 0) {
+			console.error(JSON.stringify({ ok: false, diagnostics }, null, 2));
+			process.exit(1);
+		}
+		for (const result of results) {
+			const output = tsOutputFor(result.input);
+			const outputPath = resolve(process.cwd(), output);
+			await Bun.$`mkdir -p ${dirname(outputPath)}`.quiet();
+			await Bun.write(outputPath, emitPointCoreTypeScript(result.program));
+		}
+		console.log(`Point core TypeScript build wrote ${results.length} files`);
+		return;
+	}
+
+	throw new Error(`Unknown point core command: ${command}`);
+}
+
+async function discoverInputs(): Promise<string[]> {
+	const glob = new Bun.Glob(DEFAULT_PATTERN);
+	const inputs: string[] = [];
+	for await (const input of glob.scan({ cwd: process.cwd(), onlyFiles: true })) {
+		if (!input.includes("/generated/")) inputs.push(input.replaceAll("\\", "/"));
+	}
+	return inputs.sort((a, b) => a.localeCompare(b));
+}
+
+async function loadCoreFile(input: string) {
+	const source = await Bun.file(resolve(process.cwd(), input)).text();
+	return { input, source, program: parsePointCore(source) };
+}
+
+function outputFor(input: string): string {
+	const name = input.split("/").pop()?.replace(/\.point$/, "") ?? "program";
+	return `${GENERATED_DIR}/${name}.ast.json`;
+}
+
+function tsOutputFor(input: string): string {
+	const name = input.split("/").pop()?.replace(/\.point$/, "") ?? "program";
+	return `${GENERATED_DIR}/${name}.ts`;
+}

package/src/core/context.ts

@@ -0,0 +1,217 @@
+import type {
+	PointCoreDeclaration,
+	PointCoreFunctionDeclaration,
+	PointCoreProgram,
+	PointCoreTypeDeclaration,
+	PointCoreTypeExpression,
+	PointCoreValueDeclaration,
+	PointSourceSpan,
+} from "./ast.ts";
+import type {
+	PointCoreDiagnostic,
+} from "./check.ts";
+
+export type PointCoreSymbolKind = "module" | "import" | "value" | "function" | "param" | "type" | "field";
+
+export interface PointCoreSymbol {
+	ref: string;
+	path: string;
+	kind: PointCoreSymbolKind;
+	name: string;
+	module: string;
+	type?: string;
+	mutable?: boolean;
+	from?: string;
+	span: PointSourceSpan | null;
+}
+
+export interface PointCoreIndex {
+	schemaVersion: "point.core.index.v1";
+	module: string;
+	refs: PointCoreSymbol[];
+}
+
+export interface PointCoreExplanation {
+	schemaVersion: "point.core.explain.v1";
+	ref: string;
+	found: boolean;
+	symbol?: PointCoreSymbol;
+	relatedRefs: string[];
+	summary: string;
+}
+
+export interface PointCoreRepairPlan {
+	schemaVersion: "point.core.repair-plan.v1";
+	ok: boolean;
+	steps: PointCoreRepairStep[];
+}
+
+export interface PointCoreRepairStep {
+	ref: string;
+	code: string;
+	message: string;
+	repair: string;
+	expected?: string | string[];
+	actual?: string;
+	relatedRefs: string[];
+}
+
+export function createPointCoreIndex(program: PointCoreProgram): PointCoreIndex {
+	const moduleName = program.module ?? "anonymous";
+	const refs: PointCoreSymbol[] = [
+		{
+			ref: refFor(moduleName, "module"),
+			path: "module",
+			kind: "module",
+			name: moduleName,
+			module: moduleName,
+			span: program.span ?? null,
+		},
+	];
+	for (const declaration of program.declarations) refs.push(...symbolsForDeclaration(moduleName, declaration));
+	return { schemaVersion: "point.core.index.v1", module: moduleName, refs };
+}
+
+export function explainPointCoreRef(program: PointCoreProgram, ref: string): PointCoreExplanation {
+	const index = createPointCoreIndex(program);
+	const symbol = index.refs.find((candidate) => candidate.ref === ref);
+	if (!symbol) {
+		return {
+			schemaVersion: "point.core.explain.v1",
+			ref,
+			found: false,
+			relatedRefs: [],
+			summary: `No Point symbol found for ${ref}.`,
+		};
+	}
+	const relatedRefs = relatedRefsFor(symbol, index);
+	return {
+		schemaVersion: "point.core.explain.v1",
+		ref,
+		found: true,
+		symbol,
+		relatedRefs,
+		summary: summaryFor(symbol),
+	};
+}
+
+export function createPointCoreRepairPlan(diagnostics: PointCoreDiagnostic[]): PointCoreRepairPlan {
+	return {
+		schemaVersion: "point.core.repair-plan.v1",
+		ok: diagnostics.length === 0,
+		steps: diagnostics.map((diagnostic) => ({
+			ref: diagnostic.ref,
+			code: diagnostic.code,
+			message: diagnostic.message,
+			repair: diagnostic.repair ?? "Inspect this ref and update the Point source.",
+			expected: diagnostic.expected,
+			actual: diagnostic.actual,
+			relatedRefs: diagnostic.relatedRefs ?? [],
+		})),
+	};
+}
+
+function symbolsForDeclaration(moduleName: string, declaration: PointCoreDeclaration): PointCoreSymbol[] {
+	if (declaration.kind === "import") {
+		return declaration.names.map((name) => ({
+			ref: refFor(moduleName, `import.${name}`),
+			path: `import.${name}`,
+			kind: "import",
+			name,
+			module: moduleName,
+			from: declaration.from,
+			span: declaration.span ?? null,
+		}));
+	}
+	if (declaration.kind === "value") return [valueSymbol(moduleName, declaration, `value.${declaration.name}`)];
+	if (declaration.kind === "type") return typeSymbols(moduleName, declaration);
+	return functionSymbols(moduleName, declaration);
+}
+
+function valueSymbol(moduleName: string, declaration: PointCoreValueDeclaration, path: string): PointCoreSymbol {
+	return {
+		ref: refFor(moduleName, path),
+		path,
+		kind: "value",
+		name: declaration.name,
+		module: moduleName,
+		type: formatType(declaration.type),
+		mutable: declaration.mutable,
+		span: declaration.span ?? null,
+	};
+}
+
+function typeSymbols(moduleName: string, declaration: PointCoreTypeDeclaration): PointCoreSymbol[] {
+	return [
+		{
+			ref: refFor(moduleName, `type.${declaration.name}`),
+			path: `type.${declaration.name}`,
+			kind: "type",
+			name: declaration.name,
+			module: moduleName,
+			span: declaration.span ?? null,
+		},
+		...declaration.fields.map((field) => ({
+			ref: refFor(moduleName, `type.${declaration.name}.${field.name}`),
+			path: `type.${declaration.name}.${field.name}`,
+			kind: "field" as const,
+			name: field.name,
+			module: moduleName,
+			type: formatType(field.type),
+			span: field.span ?? null,
+		})),
+	];
+}
+
+function functionSymbols(moduleName: string, declaration: PointCoreFunctionDeclaration): PointCoreSymbol[] {
+	return [
+		{
+			ref: refFor(moduleName, `fn.${declaration.name}`),
+			path: `fn.${declaration.name}`,
+			kind: "function",
+			name: declaration.name,
+			module: moduleName,
+			type: formatType(declaration.returnType),
+			span: declaration.span ?? null,
+		},
+		...declaration.params.map((param) => ({
+			ref: refFor(moduleName, `fn.${declaration.name}.param.${param.name}`),
+			path: `fn.${declaration.name}.param.${param.name}`,
+			kind: "param" as const,
+			name: param.name,
+			module: moduleName,
+			type: formatType(param.type),
+			span: param.span ?? null,
+		})),
+	];
+}
+
+function refFor(moduleName: string, path: string): string {
+	return `point://core/${moduleName}/${path}`;
+}
+
+function relatedRefsFor(symbol: PointCoreSymbol, index: PointCoreIndex): string[] {
+	if (symbol.kind === "field") {
+		const ownerPath = symbol.path.split(".").slice(0, 2).join(".");
+		return index.refs.filter((candidate) => candidate.path.startsWith(`${ownerPath}.`) && candidate.ref !== symbol.ref).map((candidate) => candidate.ref);
+	}
+	if (symbol.kind === "function") {
+		return index.refs.filter((candidate) => candidate.path.startsWith(`${symbol.path}.param.`)).map((candidate) => candidate.ref);
+	}
+	return [];
+}
+
+function summaryFor(symbol: PointCoreSymbol): string {
+	if (symbol.kind === "module") return `Module ${symbol.name}.`;
+	if (symbol.kind === "import") return `Import ${symbol.name} from ${symbol.from}.`;
+	if (symbol.kind === "value") return `${symbol.mutable ? "Mutable" : "Immutable"} value ${symbol.name}: ${symbol.type}.`;
+	if (symbol.kind === "function") return `Function ${symbol.name} returns ${symbol.type}.`;
+	if (symbol.kind === "param") return `Parameter ${symbol.name}: ${symbol.type}.`;
+	if (symbol.kind === "type") return `Named type ${symbol.name}.`;
+	return `Field ${symbol.name}: ${symbol.type}.`;
+}
+
+function formatType(type: PointCoreTypeExpression): string {
+	if (type.args.length === 0) return String(type.name);
+	return `${type.name}<${type.args.map(formatType).join(", ")}>`;
+}

package/src/core/emit-typescript.ts

@@ -0,0 +1,132 @@
+import type {
+	PointCoreDeclaration,
+	PointCoreExpression,
+	PointCoreFunctionDeclaration,
+	PointCoreParameter,
+	PointCorePrimitiveType,
+	PointCoreProgram,
+	PointCoreStatement,
+	PointCoreTypeDeclaration,
+	PointCoreTypeExpression,
+	PointCoreValueDeclaration,
+} from "./ast.ts";
+
+const BINARY_OPERATORS: Record<string, string> = {
+	and: "&&",
+	or: "||",
+};
+
+export function emitPointCoreTypeScript(program: PointCoreProgram): string {
+	const lines: string[] = [];
+	lines.push("// Generated by Point. Do not edit directly.");
+	if (program.module) lines.push(`// Point module: ${program.module}`);
+	lines.push("");
+	for (const declaration of program.declarations) {
+		lines.push(...emitDeclaration(declaration), "");
+	}
+	return `${trimTrailingBlankLines(lines).join("\n")}\n`;
+}
+
+function emitDeclaration(declaration: PointCoreDeclaration): string[] {
+	if (declaration.kind === "import") {
+		return [`import { ${declaration.names.join(", ")} } from ${JSON.stringify(declaration.from)};`];
+	}
+	if (declaration.kind === "type") return emitType(declaration);
+	if (declaration.kind === "value") return [emitValue(declaration, true)];
+	return emitFunction(declaration);
+}
+
+function emitType(declaration: PointCoreTypeDeclaration): string[] {
+	return [
+		`export interface ${declaration.name} {`,
+		...declaration.fields.map((field) => `  ${field.name}: ${emitTypeExpression(field.type)};`),
+		"}",
+	];
+}
+
+function emitFunction(declaration: PointCoreFunctionDeclaration): string[] {
+	return [
+		`export function ${declaration.name}(${declaration.params.map(emitParam).join(", ")}): ${emitTypeExpression(declaration.returnType)} {`,
+		...indentLines(declaration.body.flatMap((statement) => emitStatement(statement))),
+		"}",
+	];
+}
+
+function emitStatement(statement: PointCoreStatement): string[] {
+	if (statement.kind === "return") {
+		return [statement.value ? `return ${emitExpression(statement.value)};` : "return;"];
+	}
+	if (statement.kind === "value") return [emitValue(statement, false)];
+	if (statement.kind === "if") {
+		const lines = [
+			`if (${emitCondition(statement.condition)}) {`,
+			...indentLines(statement.thenBody.flatMap((child) => emitStatement(child))),
+			"}",
+		];
+		if (statement.elseBody.length > 0) {
+			lines.push(
+				"else {",
+				...indentLines(statement.elseBody.flatMap((child) => emitStatement(child))),
+				"}",
+			);
+		}
+		return lines;
+	}
+	return [`${emitExpression(statement.value)};`];
+}
+
+function emitValue(declaration: PointCoreValueDeclaration, exported: boolean): string {
+	const prefix = exported ? "export " : "";
+	const keyword = declaration.mutable ? "let" : "const";
+	return `${prefix}${keyword} ${declaration.name}: ${emitTypeExpression(declaration.type)} = ${emitExpression(declaration.value)};`;
+}
+
+function emitParam(param: PointCoreParameter): string {
+	return `${param.name}: ${emitTypeExpression(param.type)}`;
+}
+
+function emitTypeExpression(type: PointCoreTypeExpression): string {
+	if (type.name === "List") return `Array<${type.args[0] ? emitTypeExpression(type.args[0]) : "unknown"}>`;
+	if (isPrimitiveType(type.name)) return emitPrimitiveType(type.name);
+	return type.name;
+}
+
+function emitPrimitiveType(type: PointCorePrimitiveType): string {
+	if (type === "Text") return "string";
+	if (type === "Int" || type === "Float") return "number";
+	if (type === "Bool") return "boolean";
+	return "void";
+}
+
+function emitExpression(expression: PointCoreExpression): string {
+	if (expression.kind === "literal") return JSON.stringify(expression.value);
+	if (expression.kind === "identifier") return expression.name;
+	if (expression.kind === "list") return `[${expression.items.map(emitExpression).join(", ")}]`;
+	if (expression.kind === "record") {
+		return `{ ${expression.fields.map((field) => `${field.name}: ${emitExpression(field.value)}`).join(", ")} }`;
+	}
+	if (expression.kind === "property") return `${emitExpression(expression.target)}.${expression.name}`;
+	if (expression.kind === "call") {
+		return `${expression.callee}(${expression.args.map(emitExpression).join(", ")})`;
+	}
+	const operator = BINARY_OPERATORS[expression.operator] ?? expression.operator;
+	return `(${emitExpression(expression.left)} ${operator} ${emitExpression(expression.right)})`;
+}
+
+function emitCondition(expression: PointCoreExpression): string {
+	const emitted = emitExpression(expression);
+	return emitted.startsWith("(") && emitted.endsWith(")") ? emitted.slice(1, -1) : emitted;
+}
+
+function isPrimitiveType(type: string): type is PointCorePrimitiveType {
+	return type === "Text" || type === "Int" || type === "Float" || type === "Bool" || type === "Void";
+}
+
+function indentLines(lines: string[]): string[] {
+	return lines.map((line) => `  ${line}`);
+}
+
+function trimTrailingBlankLines(lines: string[]): string[] {
+	while (lines.at(-1) === "") lines.pop();
+	return lines;
+}

package/src/core/format.ts

@@ -0,0 +1,103 @@
+import type {
+	PointCoreDeclaration,
+	PointCoreExpression,
+	PointCoreFunctionDeclaration,
+	PointCoreParameter,
+	PointCoreProgram,
+	PointCoreStatement,
+	PointCoreTypeDeclaration,
+	PointCoreValueDeclaration,
+} from "./ast.ts";
+
+export function formatPointCore(program: PointCoreProgram): string {
+	const lines: string[] = [];
+	if (program.module) {
+		lines.push(`module ${program.module}`, "");
+	}
+	program.declarations.forEach((declaration, index) => {
+		if (index > 0) lines.push("");
+		lines.push(...formatDeclaration(declaration));
+	});
+	return `${lines.join("\n")}\n`;
+}
+
+function formatDeclaration(declaration: PointCoreDeclaration): string[] {
+	if (declaration.kind === "import") {
+		return [`import { ${declaration.names.join(", ")} } from ${JSON.stringify(declaration.from)}`];
+	}
+	if (declaration.kind === "value") return [formatValue(declaration)];
+	if (declaration.kind === "type") return formatType(declaration);
+	return formatFunction(declaration);
+}
+
+function formatType(declaration: PointCoreTypeDeclaration): string[] {
+	return [
+		`type ${declaration.name} {`,
+		...declaration.fields.map((field) => `  ${formatParam(field)}`),
+		"}",
+	];
+}
+
+function formatFunction(declaration: PointCoreFunctionDeclaration): string[] {
+	return [
+		`fn ${declaration.name}(${declaration.params.map(formatParam).join(", ")}): ${formatTypeExpression(declaration.returnType)} {`,
+		...indentLines(declaration.body.flatMap((statement) => formatStatementLines(statement))),
+		"}",
+	];
+}
+
+function formatStatementLines(statement: PointCoreStatement): string[] {
+	if (statement.kind === "return") {
+		return [statement.value ? `return ${formatExpression(statement.value)}` : "return"];
+	}
+	if (statement.kind === "value") return [formatValue(statement)];
+	if (statement.kind === "if") return formatIf(statement);
+	return [formatExpression(statement.value)];
+}
+
+function formatIf(statement: Extract<PointCoreStatement, { kind: "if" }>): string[] {
+	const lines = [
+		`if ${formatExpression(statement.condition)} {`,
+		...indentLines(statement.thenBody.flatMap((child) => formatStatementLines(child))),
+		"}",
+	];
+	if (statement.elseBody.length > 0) {
+		lines.push(
+			"else {",
+			...indentLines(statement.elseBody.flatMap((child) => formatStatementLines(child))),
+			"}",
+		);
+	}
+	return lines;
+}
+
+function formatValue(declaration: PointCoreValueDeclaration): string {
+	return `${declaration.mutable ? "var" : "let"} ${declaration.name}: ${formatTypeExpression(declaration.type)} = ${formatExpression(declaration.value)}`;
+}
+
+function formatParam(param: PointCoreParameter): string {
+	return `${param.name}: ${formatTypeExpression(param.type)}`;
+}
+
+function formatExpression(expression: PointCoreExpression): string {
+	if (expression.kind === "literal") return JSON.stringify(expression.value);
+	if (expression.kind === "identifier") return expression.name;
+	if (expression.kind === "list") return `[${expression.items.map(formatExpression).join(", ")}]`;
+	if (expression.kind === "record") {
+		return `{ ${expression.fields.map((field) => `${field.name}: ${formatExpression(field.value)}`).join(", ")} }`;
+	}
+	if (expression.kind === "property") return `${formatExpression(expression.target)}.${expression.name}`;
+	if (expression.kind === "binary") {
+		return `${formatExpression(expression.left)} ${expression.operator} ${formatExpression(expression.right)}`;
+	}
+	return `${expression.callee}(${expression.args.map(formatExpression).join(", ")})`;
+}
+
+function formatTypeExpression(type: PointCoreParameter["type"]): string {
+	if (type.args.length === 0) return String(type.name);
+	return `${type.name}<${type.args.map(formatTypeExpression).join(", ")}>`;
+}
+
+function indentLines(lines: string[]): string[] {
+	return lines.map((line) => `  ${line}`);
+}

package/src/core/index.ts

@@ -0,0 +1,7 @@
+export * from "./ast.ts";
+export * from "./check.ts";
+export * from "./context.ts";
+export * from "./emit-typescript.ts";
+export * from "./format.ts";
+export * from "./lexer.ts";
+export * from "./parser.ts";