@hatchingpoint/point 0.0.6 → 0.0.7

package/src/core/context.ts

@@ -1,16 +1,16 @@
-import type {
-	PointCoreDeclaration,
-	PointCoreFunctionDeclaration,
-	PointCoreProgram,
-	PointCoreTypeDeclaration,
-	PointCoreTypeExpression,
-	PointCoreValueDeclaration,
-	PointSourceSpan,
-} from "./ast.ts";
-import type {
-	PointCoreDiagnostic,
-} from "./check.ts";
-
+import type {
+	PointCoreDeclaration,
+	PointCoreFunctionDeclaration,
+	PointCoreProgram,
+	PointCoreTypeDeclaration,
+	PointCoreTypeExpression,
+	PointCoreValueDeclaration,
+	PointSourceSpan,
+} from "./ast.ts";
+import type {
+	PointCoreDiagnostic,
+} from "./check.ts";
+
 export type PointCoreSymbolKind =
 	| "module"
 	| "import"
@@ -30,62 +30,62 @@ export type PointCoreSymbolKind =
 	| "route"
 	| "workflow"
 	| "command";
-
-export interface PointCoreSymbol {
-	ref: string;
-	path: string;
-	kind: PointCoreSymbolKind;
-	name: string;
-	module: string;
-	type?: string;
-	mutable?: boolean;
+
+export interface PointCoreSymbol {
+	ref: string;
+	path: string;
+	kind: PointCoreSymbolKind;
+	name: string;
+	module: string;
+	type?: string;
+	mutable?: boolean;
 	from?: string;
 	effects?: 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 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,
-		},
+	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));
@@ -93,44 +93,44 @@ export function createPointCoreIndex(program: PointCoreProgram): PointCoreIndex
 	}
 	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 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 ?? [],
-		})),
-	};
+	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 ?? [],
+		})),
+	};
 }
 
 export function mapDiagnosticsToSemanticRefs(program: PointCoreProgram, diagnostics: PointCoreDiagnostic[]): PointCoreDiagnostic[] {
@@ -140,16 +140,16 @@ export function mapDiagnosticsToSemanticRefs(program: PointCoreProgram, diagnost
 		relatedRefs: diagnostic.relatedRefs?.map((ref) => semanticRefForCoreRef(program, ref) ?? ref),
 	}));
 }
-
-function symbolsForDeclaration(moduleName: string, declaration: PointCoreDeclaration): PointCoreSymbol[] {
+
+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,
+			ref: refFor(moduleName, `import.${name}`),
+			path: `import.${name}`,
+			kind: "import",
+			name,
+			module: moduleName,
+			from: declaration.from,
 			span: declaration.span ?? null,
 		}));
 	}
@@ -170,65 +170,65 @@ function symbolsForDeclaration(moduleName: string, declaration: PointCoreDeclara
 	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 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,
+	return [
+		{
+			ref: refFor(moduleName, `fn.${declaration.name}`),
+			path: `fn.${declaration.name}`,
+			kind: "function",
+			name: declaration.name,
+			module: moduleName,
 			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}`,
-			kind: "param" as const,
-			name: param.name,
-			module: moduleName,
-			type: formatType(param.type),
-			span: param.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 semanticSymbolsForDeclaration(moduleName: string, declaration: PointCoreDeclaration): PointCoreSymbol[] {
@@ -311,12 +311,12 @@ function refFor(moduleName: string, path: string): string {
 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);
-	}
+
+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" ||
 		symbol.kind === "calculation" ||
@@ -333,16 +333,16 @@ function relatedRefsFor(symbol: PointCoreSymbol, index: PointCoreIndex): string[
 			.filter((candidate) => candidate.path.startsWith(`${symbol.path}.param.`) || candidate.path.startsWith(`${symbol.path}.input.`))
 			.map((candidate) => candidate.ref);
 	}
-	return [];
-}
-
+	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 === "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 === "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 === "param") return `Parameter ${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}.`;
@@ -387,8 +387,8 @@ function semanticRefForDiagnosticPath(program: PointCoreProgram, path: string):
 	}
 	return null;
 }
-
-function formatType(type: PointCoreTypeExpression): string {
-	if (type.args.length === 0) return String(type.name);
-	return `${type.name}<${type.args.map(formatType).join(", ")}>`;
-}
+
+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-javascript.ts

@@ -1,124 +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;
-}
+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;
+}