@hatchingpoint/point 0.0.5 → 0.0.6

package/src/core/context.ts

@@ -11,7 +11,25 @@ import type {
 	PointCoreDiagnostic,
 } from "./check.ts";
 
-export type PointCoreSymbolKind = "module" | "import" | "value" | "function" | "param" | "type" | "field";
+export type PointCoreSymbolKind =
+	| "module"
+	| "import"
+	| "value"
+	| "function"
+	| "param"
+	| "type"
+	| "field"
+	| "record"
+	| "calculation"
+	| "rule"
+	| "label"
+	| "external"
+	| "action"
+	| "policy"
+	| "view"
+	| "route"
+	| "workflow"
+	| "command";
 
 export interface PointCoreSymbol {
 	ref: string;
@@ -21,8 +39,9 @@ export interface PointCoreSymbol {
 	module: string;
 	type?: string;
 	mutable?: boolean;
-	from?: string;
-	span: PointSourceSpan | null;
+	from?: string;
+	effects?: string[];
+	span: PointSourceSpan | null;
 }
 
 export interface PointCoreIndex {
@@ -56,8 +75,8 @@ export interface PointCoreRepairStep {
 	relatedRefs: string[];
 }
 
-export function createPointCoreIndex(program: PointCoreProgram): PointCoreIndex {
-	const moduleName = program.module ?? "anonymous";
+export function createPointCoreIndex(program: PointCoreProgram): PointCoreIndex {
+	const moduleName = program.module ?? "anonymous";
 	const refs: PointCoreSymbol[] = [
 		{
 			ref: refFor(moduleName, "module"),
@@ -67,10 +86,13 @@ export function createPointCoreIndex(program: PointCoreProgram): PointCoreIndex
 			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 };
-}
+	];
+	for (const declaration of program.declarations) {
+		refs.push(...symbolsForDeclaration(moduleName, declaration));
+		refs.push(...semanticSymbolsForDeclaration(moduleName, declaration));
+	}
+	return { schemaVersion: "point.core.index.v1", module: moduleName, refs };
+}
 
 export function explainPointCoreRef(program: PointCoreProgram, ref: string): PointCoreExplanation {
 	const index = createPointCoreIndex(program);
@@ -95,7 +117,7 @@ export function explainPointCoreRef(program: PointCoreProgram, ref: string): Poi
 	};
 }
 
-export function createPointCoreRepairPlan(diagnostics: PointCoreDiagnostic[]): PointCoreRepairPlan {
+export function createPointCoreRepairPlan(diagnostics: PointCoreDiagnostic[]): PointCoreRepairPlan {
 	return {
 		schemaVersion: "point.core.repair-plan.v1",
 		ok: diagnostics.length === 0,
@@ -109,23 +131,45 @@ export function createPointCoreRepairPlan(diagnostics: PointCoreDiagnostic[]): P
 			relatedRefs: diagnostic.relatedRefs ?? [],
 		})),
 	};
-}
+}
+
+export function mapDiagnosticsToSemanticRefs(program: PointCoreProgram, diagnostics: PointCoreDiagnostic[]): PointCoreDiagnostic[] {
+	return diagnostics.map((diagnostic) => ({
+		...diagnostic,
+		ref: semanticRefForDiagnosticPath(program, diagnostic.path) ?? diagnostic.ref,
+		relatedRefs: diagnostic.relatedRefs?.map((ref) => semanticRefForCoreRef(program, ref) ?? ref),
+	}));
+}
 
 function symbolsForDeclaration(moduleName: string, declaration: PointCoreDeclaration): PointCoreSymbol[] {
-	if (declaration.kind === "import") {
-		return declaration.names.map((name) => ({
+	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);
+			span: declaration.span ?? null,
+		}));
+	}
+	if (declaration.kind === "external") {
+		return [
+			{
+				ref: refFor(moduleName, `external.${declaration.name}`),
+				path: `external.${declaration.name}`,
+				kind: "external",
+				name: declaration.name,
+				module: moduleName,
+				type: formatType(declaration.returnType),
+				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 {
@@ -163,7 +207,7 @@ function typeSymbols(moduleName: string, declaration: PointCoreTypeDeclaration):
 	];
 }
 
-function functionSymbols(moduleName: string, declaration: PointCoreFunctionDeclaration): PointCoreSymbol[] {
+function functionSymbols(moduleName: string, declaration: PointCoreFunctionDeclaration): PointCoreSymbol[] {
 	return [
 		{
 			ref: refFor(moduleName, `fn.${declaration.name}`),
@@ -171,9 +215,10 @@ function functionSymbols(moduleName: string, declaration: PointCoreFunctionDecla
 			kind: "function",
 			name: declaration.name,
 			module: moduleName,
-			type: formatType(declaration.returnType),
-			span: declaration.span ?? null,
-		},
+			type: formatType(declaration.returnType),
+			effects: declaration.semantic?.effects,
+			span: declaration.span ?? null,
+		},
 		...declaration.params.map((param) => ({
 			ref: refFor(moduleName, `fn.${declaration.name}.param.${param.name}`),
 			path: `fn.${declaration.name}.param.${param.name}`,
@@ -184,32 +229,164 @@ function functionSymbols(moduleName: string, declaration: PointCoreFunctionDecla
 			span: param.span ?? null,
 		})),
 	];
-}
-
-function refFor(moduleName: string, path: string): string {
-	return `point://core/${moduleName}/${path}`;
-}
+}
+
+function semanticSymbolsForDeclaration(moduleName: string, declaration: PointCoreDeclaration): PointCoreSymbol[] {
+	if (declaration.kind === "type" && declaration.semantic?.kind === "record") {
+		const recordPath = `record.${declaration.semantic.name}`;
+		return [
+			{
+				ref: semanticRefFor(moduleName, recordPath),
+				path: recordPath,
+				kind: "record",
+				name: declaration.semantic.name,
+				module: moduleName,
+				span: declaration.span ?? null,
+			},
+			...declaration.fields.map((field) => {
+				const fieldName = field.semanticName ?? field.name;
+				const path = `${recordPath}.field.${fieldName}`;
+				return {
+					ref: semanticRefFor(moduleName, path),
+					path,
+					kind: "field" as const,
+					name: fieldName,
+					module: moduleName,
+					type: formatType(field.type),
+					span: field.span ?? null,
+				};
+			}),
+		];
+	}
+	if (declaration.kind === "function" && declaration.semantic) {
+		const semanticPath = `${declaration.semantic.kind}.${declaration.semantic.name}`;
+		return [
+			{
+				ref: semanticRefFor(moduleName, semanticPath),
+				path: semanticPath,
+				kind: declaration.semantic.kind,
+				name: declaration.semantic.name,
+				module: moduleName,
+				type: formatType(declaration.returnType),
+				effects: declaration.semantic.effects,
+				span: declaration.span ?? null,
+			},
+			...declaration.params.map((param) => {
+				const paramName = param.semanticName ?? param.name;
+				const path = `${semanticPath}.input.${paramName}`;
+				return {
+					ref: semanticRefFor(moduleName, path),
+					path,
+					kind: "param" as const,
+					name: paramName,
+					module: moduleName,
+					type: formatType(param.type),
+					span: param.span ?? null,
+				};
+			}),
+		];
+	}
+	if (declaration.kind === "external" && declaration.semantic) {
+		const semanticPath = `external.${declaration.semantic.name}`;
+		return [
+			{
+				ref: semanticRefFor(moduleName, semanticPath),
+				path: semanticPath,
+				kind: "external",
+				name: declaration.semantic.name,
+				module: moduleName,
+				type: formatType(declaration.returnType),
+				from: declaration.from,
+				span: declaration.span ?? null,
+			},
+		];
+	}
+	return [];
+}
+
+function refFor(moduleName: string, path: string): string {
+	return `point://core/${moduleName}/${path}`;
+}
+
+function semanticRefFor(moduleName: string, path: string): string {
+	return `point://semantic/${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);
-	}
+	if (
+		symbol.kind === "function" ||
+		symbol.kind === "calculation" ||
+		symbol.kind === "rule" ||
+		symbol.kind === "label" ||
+		symbol.kind === "action" ||
+		symbol.kind === "policy" ||
+		symbol.kind === "view" ||
+		symbol.kind === "route" ||
+		symbol.kind === "workflow" ||
+		symbol.kind === "command"
+	) {
+		return index.refs
+			.filter((candidate) => candidate.path.startsWith(`${symbol.path}.param.`) || candidate.path.startsWith(`${symbol.path}.input.`))
+			.map((candidate) => candidate.ref);
+	}
 	return [];
 }
 
-function summaryFor(symbol: PointCoreSymbol): string {
+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 === "function") return `Function ${symbol.name} returns ${symbol.type}.`;
+	if (symbol.kind === "external") return `External function ${symbol.name} from ${symbol.from} 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}.`;
-}
+	if (symbol.kind === "type") return `Named type ${symbol.name}.`;
+	if (symbol.kind === "record") return `Semantic record ${symbol.name}.`;
+	if (symbol.kind === "calculation") return `Semantic calculation ${symbol.name} returns ${symbol.type}.`;
+	if (symbol.kind === "rule") return `Semantic rule ${symbol.name} returns ${symbol.type}.`;
+	if (symbol.kind === "label") return `Semantic label ${symbol.name} returns ${symbol.type}.`;
+	if (symbol.kind === "action") return `Semantic action ${symbol.name} returns ${symbol.type}; effects: ${(symbol.effects ?? []).join(", ") || "none"}.`;
+	if (symbol.kind === "policy") return `Semantic policy ${symbol.name} returns ${symbol.type}.`;
+	if (symbol.kind === "view") return `Semantic view ${symbol.name} returns React JSX.`;
+	if (symbol.kind === "route") return `Semantic route ${symbol.name} returns ${symbol.type}.`;
+	if (symbol.kind === "workflow") return `Semantic workflow ${symbol.name} returns ${symbol.type}.`;
+	if (symbol.kind === "command") return `Semantic command ${symbol.name} returns ${symbol.type}.`;
+	return `Field ${symbol.name}: ${symbol.type}.`;
+}
+
+function semanticRefForCoreRef(program: PointCoreProgram, ref: string): string | null {
+	const prefix = `point://core/${program.module ?? "anonymous"}/`;
+	if (!ref.startsWith(prefix)) return null;
+	return semanticRefForDiagnosticPath(program, ref.slice(prefix.length));
+}
+
+function semanticRefForDiagnosticPath(program: PointCoreProgram, path: string): string | null {
+	const moduleName = program.module ?? "anonymous";
+	for (const declaration of program.declarations) {
+		if (declaration.kind === "type" && declaration.semantic?.kind === "record") {
+			const recordPath = `type.${declaration.name}`;
+			if (path === recordPath || path.startsWith(`${recordPath}.`)) {
+				const parts = path.split(".");
+				const field = parts.length >= 3 ? declaration.fields.find((candidate) => candidate.name === parts[2]) : undefined;
+				const semanticPath = field
+					? `record.${declaration.semantic.name}.field.${field.semanticName ?? field.name}`
+					: `record.${declaration.semantic.name}`;
+				return semanticRefFor(moduleName, semanticPath);
+			}
+		}
+		if ((declaration.kind === "function" || declaration.kind === "external") && declaration.semantic) {
+			const fnPath = `fn.${declaration.name}`;
+			if (path === fnPath || path.startsWith(`${fnPath}.`)) {
+				const semanticPath = `${declaration.semantic.kind}.${declaration.semantic.name}`;
+				return semanticRefFor(moduleName, semanticPath);
+			}
+		}
+	}
+	return null;
+}
 
 function formatType(type: PointCoreTypeExpression): string {
 	if (type.args.length === 0) return String(type.name);

package/src/core/emit-javascript.ts

@@ -0,0 +1,124 @@
+import type {
+	PointCoreDeclaration,
+	PointCoreExpression,
+	PointCoreFunctionDeclaration,
+	PointCoreParameter,
+	PointCoreProgram,
+	PointCoreStatement,
+	PointCoreTypeDeclaration,
+	PointCoreValueDeclaration,
+} from "./ast.ts";
+
+const BINARY_OPERATORS: Record<string, string> = {
+	and: "&&",
+	or: "||",
+};
+
+/** Emit JavaScript from a core AST program (no type syntax). Production path: parsePointSource → check → emit. */
+export function emitPointCoreJavaScript(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 === "external") {
+		const imported = declaration.importName ? `${declaration.importName} as ${declaration.name}` : declaration.name;
+		return [`import { ${imported} } from ${JSON.stringify(declaration.from)};`];
+	}
+	if (declaration.kind === "type") return [];
+	if (declaration.kind === "value") return [emitValue(declaration, true)];
+	return emitFunction(declaration);
+}
+
+function emitFunction(declaration: PointCoreFunctionDeclaration): string[] {
+	const asyncPrefix = declaration.semantic?.kind === "action" || declaration.semantic?.kind === "workflow" || declaration.semantic?.kind === "command" ? "async " : "";
+	return [
+		`export ${asyncPrefix}function ${declaration.name}(${declaration.params.map(emitParam).join(", ")}) {`,
+		...indentLines(declaration.body.flatMap((statement) => emitStatement(statement, declaration.semantic?.kind))),
+		"}",
+	];
+}
+
+function emitStatement(statement: PointCoreStatement, semanticKind?: string): string[] {
+	if (statement.kind === "return") {
+		if (semanticKind === "view" && statement.value?.kind === "literal" && typeof statement.value.value === "string") {
+			return [`return ${JSON.stringify(statement.value.value)};`];
+		}
+		return [statement.value ? `return ${emitExpression(statement.value)};` : "return;"];
+	}
+	if (statement.kind === "value") return [emitValue(statement, false)];
+	if (statement.kind === "assignment") return [`${statement.name} ${statement.operator} ${emitExpression(statement.value)};`];
+	if (statement.kind === "if") {
+		const lines = [
+			`if (${emitCondition(statement.condition)}) {`,
+			...indentLines(statement.thenBody.flatMap((child) => emitStatement(child, semanticKind))),
+			"}",
+		];
+		if (statement.elseBody.length > 0) {
+			lines.push(
+				"else {",
+				...indentLines(statement.elseBody.flatMap((child) => emitStatement(child, semanticKind))),
+				"}",
+			);
+		}
+		return lines;
+	}
+	if (statement.kind === "for") {
+		return [
+			`for (const ${statement.itemName} of ${emitExpression(statement.iterable)}) {`,
+			...indentLines(statement.body.flatMap((child) => emitStatement(child, semanticKind))),
+			"}",
+		];
+	}
+	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} = ${emitExpression(declaration.value)};`;
+}
+
+function emitParam(param: PointCoreParameter): string {
+	return param.name;
+}
+
+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 === "await") return `await ${emitExpression(expression.value)}`;
+	if (expression.kind === "property") return `${emitExpression(expression.target)}.${expression.name}`;
+	if (expression.kind === "call") {
+		if (expression.callee === "Error") return `{ message: ${expression.args[0] ? emitExpression(expression.args[0]) : JSON.stringify("")} }`;
+		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 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/emit-typescript.ts

@@ -16,6 +16,7 @@ const BINARY_OPERATORS: Record<string, string> = {
 	or: "||",
 };
 
+/** Emit TypeScript from a core AST program. Production path: parsePointSource → check → emit. */
 export function emitPointCoreTypeScript(program: PointCoreProgram): string {
 	const lines: string[] = [];
 	lines.push("// Generated by Point. Do not edit directly.");
@@ -31,6 +32,10 @@ function emitDeclaration(declaration: PointCoreDeclaration): string[] {
 	if (declaration.kind === "import") {
 		return [`import { ${declaration.names.join(", ")} } from ${JSON.stringify(declaration.from)};`];
 	}
+	if (declaration.kind === "external") {
+		const imported = declaration.importName ? `${declaration.importName} as ${declaration.name}` : declaration.name;
+		return [`import { ${imported} } from ${JSON.stringify(declaration.from)};`];
+	}
 	if (declaration.kind === "type") return emitType(declaration);
 	if (declaration.kind === "value") return [emitValue(declaration, true)];
 	return emitFunction(declaration);
@@ -45,15 +50,27 @@ function emitType(declaration: PointCoreTypeDeclaration): string[] {
 }
 
 function emitFunction(declaration: PointCoreFunctionDeclaration): string[] {
+	const asyncPrefix = declaration.semantic?.kind === "action" || declaration.semantic?.kind === "workflow" || declaration.semantic?.kind === "command" ? "async " : "";
+	const returnType =
+		declaration.semantic?.kind === "action" || declaration.semantic?.kind === "workflow" || declaration.semantic?.kind === "command"
+			? `Promise<${emitTypeExpression(declaration.returnType)}>`
+			: declaration.semantic?.kind === "view"
+				? "JSX.Element"
+				: declaration.semantic?.kind === "route"
+					? "Response | string"
+				: emitTypeExpression(declaration.returnType);
 	return [
-		`export function ${declaration.name}(${declaration.params.map(emitParam).join(", ")}): ${emitTypeExpression(declaration.returnType)} {`,
-		...indentLines(declaration.body.flatMap((statement) => emitStatement(statement))),
+		`export ${asyncPrefix}function ${declaration.name}(${declaration.params.map(emitParam).join(", ")}): ${returnType} {`,
+		...indentLines(declaration.body.flatMap((statement) => emitStatement(statement, declaration.semantic?.kind))),
 		"}",
 	];
 }
 
-function emitStatement(statement: PointCoreStatement): string[] {
+function emitStatement(statement: PointCoreStatement, semanticKind?: string): string[] {
 	if (statement.kind === "return") {
+		if (semanticKind === "view" && statement.value?.kind === "literal" && typeof statement.value.value === "string") {
+			return [`return <>${escapeJsxText(statement.value.value)}</>;`];
+		}
 		return [statement.value ? `return ${emitExpression(statement.value)};` : "return;"];
 	}
 	if (statement.kind === "value") return [emitValue(statement, false)];
@@ -61,21 +78,32 @@ function emitStatement(statement: PointCoreStatement): string[] {
 	if (statement.kind === "if") {
 		const lines = [
 			`if (${emitCondition(statement.condition)}) {`,
-			...indentLines(statement.thenBody.flatMap((child) => emitStatement(child))),
+			...indentLines(statement.thenBody.flatMap((child) => emitStatement(child, semanticKind))),
 			"}",
 		];
 		if (statement.elseBody.length > 0) {
 			lines.push(
 				"else {",
-				...indentLines(statement.elseBody.flatMap((child) => emitStatement(child))),
+				...indentLines(statement.elseBody.flatMap((child) => emitStatement(child, semanticKind))),
 				"}",
 			);
 		}
 		return lines;
 	}
+	if (statement.kind === "for") {
+		return [
+			`for (const ${statement.itemName} of ${emitExpression(statement.iterable)}) {`,
+			...indentLines(statement.body.flatMap((child) => emitStatement(child, semanticKind))),
+			"}",
+		];
+	}
 	return [`${emitExpression(statement.value)};`];
 }
 
+function escapeJsxText(value: string): string {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+
 function emitValue(declaration: PointCoreValueDeclaration, exported: boolean): string {
 	const prefix = exported ? "export " : "";
 	const keyword = declaration.mutable ? "let" : "const";
@@ -88,6 +116,9 @@ function emitParam(param: PointCoreParameter): string {
 
 function emitTypeExpression(type: PointCoreTypeExpression): string {
 	if (type.name === "List") return `Array<${type.args[0] ? emitTypeExpression(type.args[0]) : "unknown"}>`;
+	if (type.name === "Maybe") return `${type.args[0] ? emitTypeExpression(type.args[0]) : "unknown"} | null`;
+	if (type.name === "Or") return type.args.map(emitTypeExpression).join(" | ");
+	if (type.name === "Error") return "{ message: string }";
 	if (isPrimitiveType(type.name)) return emitPrimitiveType(type.name);
 	return type.name;
 }
@@ -106,8 +137,10 @@ function emitExpression(expression: PointCoreExpression): string {
 	if (expression.kind === "record") {
 		return `{ ${expression.fields.map((field) => `${field.name}: ${emitExpression(field.value)}`).join(", ")} }`;
 	}
+	if (expression.kind === "await") return `await ${emitExpression(expression.value)}`;
 	if (expression.kind === "property") return `${emitExpression(expression.target)}.${expression.name}`;
 	if (expression.kind === "call") {
+		if (expression.callee === "Error") return `{ message: ${expression.args[0] ? emitExpression(expression.args[0]) : JSON.stringify("")} }`;
 		return `${expression.callee}(${expression.args.map(emitExpression).join(", ")})`;
 	}
 	const operator = BINARY_OPERATORS[expression.operator] ?? expression.operator;

package/src/core/format.ts

@@ -1,104 +1,6 @@
-import type {
-	PointCoreDeclaration,
-	PointCoreExpression,
-	PointCoreFunctionDeclaration,
-	PointCoreParameter,
-	PointCoreProgram,
-	PointCoreStatement,
-	PointCoreTypeDeclaration,
-	PointCoreValueDeclaration,
-} from "./ast.ts";
+import { formatSemanticProgram } from "../semantic/format.ts";
+import { parseSemanticSource } from "../semantic/parse.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 === "assignment") return [`${statement.name} ${statement.operator} ${formatExpression(statement.value)}`];
-	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}`);
+export function formatPointSource(source: string): string {
+	return formatSemanticProgram(parseSemanticSource(source));
 }