@hatchingpoint/point 0.0.5 → 0.0.6

package/src/semantic/expressions.ts

@@ -0,0 +1,347 @@
+import type { PointSourceSpan } from "../core/ast.ts";
+import { lexPointCore } from "../core/lexer.ts";
+import type {
+	PointSemanticBinaryOperator,
+	PointSemanticExpression,
+	PointSemanticRecordLiteralField,
+	PointSemanticTypeExpression,
+} from "./ast.ts";
+
+export interface PointSemanticExpressionContext {
+	bindings: string[];
+	atoms: string[];
+	callables: string[];
+	recordFields: Map<string, string[]>;
+}
+
+export function parseSemanticTypeExpression(source: string): PointSemanticTypeExpression {
+	const trimmed = source.trim();
+	const orParts = splitTopLevel(trimmed, " or ");
+	if (orParts.length > 1) {
+		return {
+			kind: "typeRef",
+			name: "Or",
+			args: orParts.map(parseSemanticTypeExpression),
+		};
+	}
+	const listMatch = trimmed.match(/^List<(.+)>$/);
+	if (listMatch) {
+		return { kind: "typeRef", name: "List", args: [parseSemanticTypeExpression(listMatch[1] ?? "")] };
+	}
+	const maybeMatch = trimmed.match(/^Maybe<(.+)>$/);
+	if (maybeMatch) {
+		return { kind: "typeRef", name: "Maybe", args: [parseSemanticTypeExpression(maybeMatch[1] ?? "")] };
+	}
+	return { kind: "typeRef", name: trimmed, args: [] };
+}
+
+export function parseSemanticExpression(
+	source: string,
+	context: PointSemanticExpressionContext,
+	span?: PointSourceSpan,
+): PointSemanticExpression {
+	const errorMatch = source.trim().match(/^Error\s+("(?:\\.|[^"\\])*")$/);
+	if (errorMatch) {
+		const expression: PointSemanticExpression = { kind: "error", message: JSON.parse(errorMatch[1] ?? '""') as string };
+		return span ? withExpressionSpan(expression, span) : expression;
+	}
+	const expression = parseBinaryExpression(source.trim(), 0, context).expression;
+	return span ? withExpressionSpan(expression, span) : expression;
+}
+
+export function withExpressionSpan(expression: PointSemanticExpression, span: PointSourceSpan): PointSemanticExpression {
+	switch (expression.kind) {
+		case "literal":
+		case "name":
+		case "error":
+			return { ...expression, span: expression.span ?? span };
+		case "property":
+			return {
+				...expression,
+				span: expression.span ?? span,
+				target: withExpressionSpan(expression.target, span),
+			};
+		case "binary":
+			return {
+				...expression,
+				span: expression.span ?? span,
+				left: withExpressionSpan(expression.left, span),
+				right: withExpressionSpan(expression.right, span),
+			};
+		case "call":
+			return {
+				...expression,
+				span: expression.span ?? span,
+				args: expression.args.map((arg) => withExpressionSpan(arg, span)),
+			};
+		case "await":
+			return {
+				...expression,
+				span: expression.span ?? span,
+				value: withExpressionSpan(expression.value, span),
+			};
+		case "list":
+			return {
+				...expression,
+				span: expression.span ?? span,
+				items: expression.items.map((item) => withExpressionSpan(item, span)),
+			};
+		case "record":
+			return {
+				...expression,
+				span: expression.span ?? span,
+				fields: expression.fields.map((field) => ({
+					...field,
+					value: withExpressionSpan(field.value, span),
+				})),
+			};
+	}
+}
+
+function parseBinaryExpression(
+	source: string,
+	minPrecedence: number,
+	context: PointSemanticExpressionContext,
+): { expression: PointSemanticExpression; consumed: string } {
+	let left = parsePrimaryExpression(source, context);
+	let rest = left.consumed.trimStart();
+	while (rest) {
+		const operator = peekBinaryOperator(rest);
+		if (!operator) break;
+		const precedence = precedenceFor(operator.op);
+		if (precedence < minPrecedence) break;
+		const right = parseBinaryExpression(operator.rest.trimStart(), precedence + 1, context);
+		left = {
+			expression: {
+				kind: "binary",
+				operator: operator.op,
+				left: left.expression,
+				right: right.expression,
+			},
+			consumed: right.consumed,
+		};
+		rest = left.consumed.trimStart();
+	}
+	return left;
+}
+
+function parsePrimaryExpression(source: string, context: PointSemanticExpressionContext): { expression: PointSemanticExpression; consumed: string } {
+	const trimmed = source.trim();
+	if (trimmed.startsWith("await ")) {
+		const inner = parsePrimaryExpression(trimmed.slice("await ".length), context);
+		return { expression: { kind: "await", value: inner.expression }, consumed: inner.consumed };
+	}
+	if (trimmed.startsWith("[")) {
+		return parseListExpression(trimmed, context);
+	}
+	if (trimmed.startsWith("{")) {
+		return parseRecordExpression(trimmed, context);
+	}
+	if (trimmed.startsWith('"')) {
+		const end = trimmed.indexOf('"', 1);
+		const value = JSON.parse(trimmed.slice(0, end + 1));
+		return { expression: { kind: "literal", value }, consumed: trimmed.slice(end + 1) };
+	}
+	if (/^(true|false|null|none)\b/.test(trimmed)) {
+		const match = trimmed.match(/^(true|false|null|none)\b/);
+		const token = match?.[1];
+		const value = token === "true" ? true : token === "false" ? false : null;
+		return { expression: { kind: "literal", value }, consumed: trimmed.slice(match?.[0].length ?? 0) };
+	}
+	if (/^\d/.test(trimmed)) {
+		const match = trimmed.match(/^(\d+(?:\.\d+)?)/);
+		const value = Number(match?.[1] ?? 0);
+		return { expression: { kind: "literal", value }, consumed: trimmed.slice(match?.[0].length ?? 0) };
+	}
+	const callMatch = matchCall(trimmed, context);
+	if (callMatch) return callMatch;
+	const atom = matchAtom(trimmed, context);
+	if (atom) {
+		if (atom.includes(".")) {
+			const dot = atom.indexOf(".");
+			return {
+				expression: {
+					kind: "property",
+					target: { kind: "name", label: atom.slice(0, dot) },
+					label: atom.slice(dot + 1),
+				},
+				consumed: trimmed.slice(atom.length),
+			};
+		}
+		let expression: PointSemanticExpression = { kind: "name", label: atom };
+		let consumed = trimmed.slice(atom.length);
+		while (consumed.trimStart().startsWith(".")) {
+			let rest = consumed.trimStart().slice(1);
+			const fieldMatch = rest.match(/^([A-Za-z][A-Za-z0-9 ]*[A-Za-z0-9]|[A-Za-z])/);
+			if (!fieldMatch) break;
+			const label = fieldMatch[0] ?? "";
+			expression = { kind: "property", target: expression, label };
+			consumed = rest.slice(label.length);
+		}
+		return { expression, consumed };
+	}
+	throw new Error(`Unable to parse semantic expression: ${source}`);
+}
+
+function parseListExpression(source: string, context: PointSemanticExpressionContext): { expression: PointSemanticExpression; consumed: string } {
+	let rest = source.trim().slice(1).trimStart();
+	const items: PointSemanticExpression[] = [];
+	while (rest && !rest.startsWith("]")) {
+		const parsed = parseBinaryExpression(rest, 0, context);
+		items.push(parsed.expression);
+		rest = parsed.consumed.trimStart();
+		if (rest.startsWith(",")) rest = rest.slice(1).trimStart();
+	}
+	if (!rest.startsWith("]")) throw new Error(`Unterminated list literal: ${source}`);
+	return { expression: { kind: "list", items }, consumed: rest.slice(1) };
+}
+
+function parseRecordExpression(source: string, context: PointSemanticExpressionContext): { expression: PointSemanticExpression; consumed: string } {
+	let rest = source.trim().slice(1).trimStart();
+	const fields: PointSemanticRecordLiteralField[] = [];
+	while (rest && !rest.startsWith("}")) {
+		const colon = rest.indexOf(":");
+		if (colon === -1) throw new Error(`Expected record field label: ${source}`);
+		const label = rest.slice(0, colon).trim();
+		rest = rest.slice(colon + 1).trimStart();
+		const parsed = parseBinaryExpression(rest, 0, context);
+		fields.push({ label, value: parsed.expression });
+		rest = parsed.consumed.trimStart();
+		if (rest.startsWith(",")) rest = rest.slice(1).trimStart();
+	}
+	if (!rest.startsWith("}")) throw new Error(`Unterminated record literal: ${source}`);
+	return { expression: { kind: "record", fields }, consumed: rest.slice(1) };
+}
+
+function matchCall(source: string, context: PointSemanticExpressionContext): { expression: PointSemanticExpression; consumed: string } | null {
+	const candidates = [...context.callables, ...context.atoms, ...context.bindings].sort((a, b) => b.length - a.length);
+	for (const callee of candidates) {
+		const parsed = parseCallExpression(source, callee, context);
+		if (parsed) return parsed;
+	}
+	const generic = source.match(/^([A-Za-z_][A-Za-z0-9_]*)\(/);
+	if (generic) return parseCallExpression(source, generic[1] ?? "", context);
+	return null;
+}
+
+function parseCallExpression(
+	source: string,
+	callee: string,
+	context: PointSemanticExpressionContext,
+): { expression: PointSemanticExpression; consumed: string } | null {
+	if (!source.startsWith(callee)) return null;
+	const after = source.slice(callee.length);
+	if (!after.startsWith("(")) return null;
+	let depth = 0;
+	let index = 0;
+	for (; index < after.length; index += 1) {
+		const char = after[index];
+		if (char === "(") depth += 1;
+		if (char === ")") {
+			depth -= 1;
+			if (depth === 0) break;
+		}
+	}
+	const argSource = after.slice(1, index);
+	const args = argSource.trim() ? splitTopLevel(argSource, ",").map((part) => parseSemanticExpression(part, context)) : [];
+	return {
+		expression: { kind: "call", callee, args },
+		consumed: source.slice(callee.length + index + 1),
+	};
+}
+
+function matchAtom(source: string, context: PointSemanticExpressionContext): string | null {
+	for (const atom of [...context.atoms, ...context.bindings].sort((a, b) => b.length - a.length)) {
+		if (!source.startsWith(atom)) continue;
+		const next = source[atom.length];
+		if (next && /[A-Za-z0-9_]/.test(next)) continue;
+		return atom;
+	}
+	return null;
+}
+
+function peekBinaryOperator(source: string): { op: PointSemanticBinaryOperator; rest: string } | null {
+	for (const op of ["==", "!=", "<=", ">=", "and", "or", "+", "-", "*", "/", "<", ">"] as const) {
+		if (source.startsWith(op)) {
+			const next = source[op.length];
+			if (op === "-" && /^\d/.test(source)) return null;
+			if (next && /[A-Za-z0-9_]/.test(next) && !["and", "or"].includes(op)) continue;
+			return { op, rest: source.slice(op.length) };
+		}
+	}
+	return null;
+}
+
+function precedenceFor(operator: PointSemanticBinaryOperator): number {
+	if (operator === "or") return 1;
+	if (operator === "and") return 2;
+	if (operator === "==" || operator === "!=") return 3;
+	if (operator === "<" || operator === "<=" || operator === ">" || operator === ">=") return 4;
+	if (operator === "+" || operator === "-") return 5;
+	return 6;
+}
+
+function splitTopLevel(source: string, separator: string): string[] {
+	const parts: string[] = [];
+	let depth = 0;
+	let quote: '"' | null = null;
+	let current = "";
+	for (let index = 0; index < source.length; index += 1) {
+		const char = source[index];
+		if (quote) {
+			current += char;
+			if (char === quote && source[index - 1] !== "\\") quote = null;
+			continue;
+		}
+		if (char === '"') {
+			quote = '"';
+			current += char;
+			continue;
+		}
+		if (char === "<" || char === "(" || char === "[") depth += 1;
+		if (char === ">" || char === ")" || char === "]") depth -= 1;
+		if (depth === 0 && source.slice(index, index + separator.length) === separator) {
+			parts.push(current.trim());
+			current = "";
+			index += separator.length - 1;
+			continue;
+		}
+		current += char;
+	}
+	if (current.trim()) parts.push(current.trim());
+	return parts;
+}
+
+export function buildExpressionContext(options: {
+	bindings?: string[];
+	paramTypes?: Map<string, string>;
+	recordFields?: Map<string, Map<string, string>>;
+	callables?: string[];
+}): PointSemanticExpressionContext {
+	const bindings = options.bindings ?? [];
+	const callables = options.callables ?? [];
+	const atoms: string[] = [...bindings];
+	const recordFields = new Map<string, string[]>();
+	for (const [param, type] of options.paramTypes ?? []) {
+		const fields = options.recordFields?.get(type);
+		if (!fields) continue;
+		recordFields.set(type, [...fields.keys()]);
+		for (const label of fields.keys()) atoms.push(`${param}.${label}`);
+	}
+	return { bindings, atoms, callables, recordFields };
+}
+
+export function lineSpan(source: string, lineNumber: number): PointSourceSpan {
+	const lines = source.split(/\r?\n/);
+	let offset = 0;
+	for (let index = 0; index < lineNumber - 1; index += 1) offset += (lines[index]?.length ?? 0) + 1;
+	const line = lines[lineNumber - 1] ?? "";
+	return {
+		start: { line: lineNumber, column: 1, offset },
+		end: { line: lineNumber, column: line.length + 1, offset: offset + line.length },
+	};
+}
+
+export function validateExpressionWithLexer(source: string): void {
+	lexPointCore(source.replace(/\band\b/g, "&&").replace(/\bor\b/g, "||"));
+}

package/src/semantic/format.ts

@@ -0,0 +1,222 @@
+import type {
+	PointSemanticBinding,
+	PointSemanticCalculationStatement,
+	PointSemanticCommandStatement,
+	PointSemanticDeclaration,
+	PointSemanticExpression,
+	PointSemanticLabelStatement,
+	PointSemanticMutationStatement,
+	PointSemanticOutputBinding,
+	PointSemanticPolicyStatement,
+	PointSemanticProgram,
+	PointSemanticRouteStatement,
+	PointSemanticRuleStatement,
+	PointSemanticTypeExpression,
+	PointSemanticViewStatement,
+	PointSemanticWorkflowStatement,
+	PointSemanticActionStatement,
+} from "./ast.ts";
+
+export function formatSemanticProgram(program: PointSemanticProgram): string {
+	const blocks: string[] = [];
+	if (program.module) blocks.push(`module ${program.module}`);
+	for (const use of program.uses) {
+		blocks.push(use.from ? `use ${use.moduleName} from ${JSON.stringify(use.from)}` : `use ${use.moduleName}`);
+	}
+	for (const declaration of program.declarations) {
+		blocks.push(formatDeclaration(declaration).join("\n"));
+	}
+	return `${blocks.join("\n\n")}\n`;
+}
+
+function formatDeclaration(declaration: PointSemanticDeclaration): string[] {
+	switch (declaration.kind) {
+		case "record":
+			return [`record ${declaration.name}`, ...declaration.fields.map((field) => `  ${field.label}: ${formatType(field.type)}`)];
+		case "external":
+			return [
+				`external ${declaration.name}`,
+				...declaration.functions.map(
+					(fn) =>
+						`  ${fn.label}(${fn.params.map(formatBinding).join(", ")}): ${formatType(fn.returnType)} from ${JSON.stringify(fn.from)}${fn.importAs ? ` as ${fn.importAs}` : ""}`,
+				),
+			];
+		case "calculation":
+			return [
+				`calculation ${declaration.name}`,
+				...formatInputs(declaration.inputs),
+				...formatOutput(declaration.output, declaration.kind),
+				...declaration.body.map((statement) => `  ${formatCalculationStatement(statement)}`),
+			];
+		case "rule":
+			return [
+				`rule ${declaration.name}`,
+				...formatInputs(declaration.inputs),
+				...formatOutput(declaration.output, declaration.kind),
+				...declaration.body.flatMap((statement) => formatRuleStatement(statement)),
+			];
+		case "label":
+			return [
+				`label ${declaration.name}`,
+				...formatInputs(declaration.inputs),
+				...formatOutput(declaration.output, declaration.kind),
+				...declaration.body.map((statement) => `  ${formatLabelStatement(statement)}`),
+			];
+		case "action":
+			return [
+				`action ${declaration.name}`,
+				...formatInputs(declaration.inputs),
+				...formatOutput(declaration.output, declaration.kind),
+				...(declaration.touches.length > 0 ? [`  touches ${declaration.touches.join(", ")}`] : []),
+				...declaration.body.map((statement) => `  ${formatActionStatement(statement)}`),
+			];
+		case "policy":
+			return [
+				`policy ${declaration.name}`,
+				...formatInputs(declaration.inputs),
+				...declaration.body.map((statement) => `  ${formatPolicyStatement(statement)}`),
+			];
+		case "view":
+			return [
+				`view ${declaration.name}`,
+				...formatInputs(declaration.inputs),
+				...formatViewOutput(declaration.output),
+				...declaration.body.map((statement) => `  ${formatViewStatement(statement)}`),
+			];
+		case "route":
+			return [
+				`route ${declaration.name}`,
+				`  method ${declaration.method}`,
+				`  path ${JSON.stringify(declaration.path)}`,
+				...formatInputs(declaration.inputs).map((line) => `  ${line.trimStart()}`),
+				...formatOutput(declaration.output, declaration.kind).map((line) => `  ${line.trimStart()}`),
+				...declaration.body.map((statement) => `  ${formatRouteStatement(statement)}`),
+			];
+		case "workflow":
+			return [
+				`workflow ${declaration.name}`,
+				...formatInputs(declaration.inputs),
+				...formatOutput(declaration.output, declaration.kind),
+				...declaration.body.map((statement) => `  ${formatWorkflowStatement(statement)}`),
+			];
+		case "command":
+			return [
+				`command ${declaration.name}`,
+				...formatInputs(declaration.inputs),
+				...formatOutput(declaration.output, declaration.kind),
+				...declaration.body.map((statement) => `  ${formatCommandStatement(statement)}`),
+			];
+	}
+}
+
+function formatInputs(inputs: PointSemanticBinding[]): string[] {
+	return inputs.map((input) => `  input ${formatBinding(input)}`);
+}
+
+function formatBinding(binding: PointSemanticBinding): string {
+	return `${binding.label}: ${formatType(binding.type)}`;
+}
+
+function formatOutput(output: PointSemanticOutputBinding, kind: PointSemanticDeclaration["kind"]): string[] {
+	if (kind === "label" && output.name === "result") return [`  output ${formatType(output.type)}`];
+	if (kind === "policy") return [];
+	if (kind === "view" && output.name === "page" && output.type.name === "Page") return [];
+	if (output.type.name === "Void" && output.name === "result") {
+		if (kind === "action" || kind === "command") return ["  output Void"];
+		if (kind === "calculation" || kind === "rule" || kind === "workflow") return [];
+	}
+	return [`  output ${output.name}: ${formatType(output.type)}`];
+}
+
+function formatViewOutput(output: PointSemanticOutputBinding): string[] {
+	if (output.name === "page" && output.type.name === "Page") return [];
+	return formatOutput(output, "view");
+}
+
+function formatCalculationStatement(statement: PointSemanticCalculationStatement): string {
+	if (statement.kind === "assignIs") return `${statement.name} is ${formatExpression(statement.value)}`;
+	if (statement.kind === "startsAt") return `${statement.name} starts at ${formatExpression(statement.value)}`;
+	if (statement.kind === "startsAs") return `${statement.name} starts as ${formatExpression(statement.value)}`;
+	if (statement.kind === "forEach") {
+		return [`for each ${statement.item} in ${formatExpression(statement.iterable)}`, ...statement.body.map((mutation) => `  ${formatMutation(mutation)}`)].join(
+			"\n",
+		);
+	}
+	if (statement.kind === "return") return `return ${formatExpression(statement.value)}`;
+	return formatMutation(statement);
+}
+
+function formatRuleStatement(statement: PointSemanticRuleStatement): string[] {
+	if (statement.kind === "startsAt") return [`  ${statement.name} starts at ${formatExpression(statement.value)}`];
+	if (statement.kind === "addWhen") return [`  add ${formatExpression(statement.amount)} when ${formatExpression(statement.condition)}`];
+	if (statement.kind === "forEach") {
+		return [
+			`  for each ${statement.item} in ${formatExpression(statement.iterable)}`,
+			...statement.body.map((mutation) => `  ${formatMutation(mutation)}`),
+		];
+	}
+	if (statement.kind === "return") return [`  return ${formatExpression(statement.value)}`];
+	return [`  ${formatMutation(statement)}`];
+}
+
+function formatLabelStatement(statement: PointSemanticLabelStatement): string {
+	if (statement.kind === "whenReturn") return `when ${formatExpression(statement.condition)} return ${formatExpression(statement.value)}`;
+	return `otherwise return ${formatExpression(statement.value)}`;
+}
+
+function formatActionStatement(statement: PointSemanticActionStatement): string {
+	return `return ${formatExpression(statement.value)}`;
+}
+
+function formatPolicyStatement(statement: PointSemanticPolicyStatement): string {
+	if (statement.kind === "deny") return `deny ${formatExpression(statement.condition)}`;
+	if (statement.kind === "require") return `require ${formatExpression(statement.condition)}`;
+	return `allow ${formatExpression(statement.condition)}`;
+}
+
+function formatViewStatement(statement: PointSemanticViewStatement): string {
+	if (statement.kind === "whenRender") return `when ${formatExpression(statement.condition)} render ${formatExpression(statement.value)}`;
+	return `render ${formatExpression(statement.value)}`;
+}
+
+function formatRouteStatement(statement: PointSemanticRouteStatement): string {
+	return `return ${formatExpression(statement.value)}`;
+}
+
+function formatWorkflowStatement(statement: PointSemanticWorkflowStatement): string {
+	if (statement.kind === "step") return `step ${statement.name} is ${formatExpression(statement.value)}`;
+	return `return ${formatExpression(statement.value)}`;
+}
+
+function formatCommandStatement(statement: PointSemanticCommandStatement): string {
+	return `return ${formatExpression(statement.value)}`;
+}
+
+function formatMutation(statement: PointSemanticMutationStatement): string {
+	if (statement.kind === "addTo") return `add ${formatExpression(statement.amount)} to ${statement.target}`;
+	if (statement.kind === "subtractFrom") return `subtract ${formatExpression(statement.amount)} from ${statement.target}`;
+	return `set ${statement.target} to ${formatExpression(statement.value)}`;
+}
+
+function formatExpression(expression: PointSemanticExpression): string {
+	if (expression.kind === "literal") {
+		if (expression.value === null) return "none";
+		return JSON.stringify(expression.value);
+	}
+	if (expression.kind === "name") return expression.label;
+	if (expression.kind === "property") return `${formatExpression(expression.target)}.${expression.label}`;
+	if (expression.kind === "binary") return `${formatExpression(expression.left)} ${expression.operator} ${formatExpression(expression.right)}`;
+	if (expression.kind === "call") return `${expression.callee}(${expression.args.map(formatExpression).join(", ")})`;
+	if (expression.kind === "await") return `await ${formatExpression(expression.value)}`;
+	if (expression.kind === "list") return `[${expression.items.map(formatExpression).join(", ")}]`;
+	if (expression.kind === "record") {
+		return `{ ${expression.fields.map((field) => `${field.label}: ${formatExpression(field.value)}`).join(", ")} }`;
+	}
+	return `Error ${JSON.stringify(expression.message)}`;
+}
+
+function formatType(type: PointSemanticTypeExpression): string {
+	if (type.name === "Or") return type.args.map(formatType).join(" or ");
+	if (type.args.length === 0) return type.name;
+	return `${type.name}<${type.args.map(formatType).join(", ")}>`;
+}

package/src/semantic/index.ts

@@ -0,0 +1,10 @@
+export * from "./ast.ts";
+export * from "./callables.ts";
+export * from "./context.ts";
+export * from "./desugar.ts";
+export * from "./expressions.ts";
+export * from "./format.ts";
+export * from "./metadata.ts";
+export * from "./naming.ts";
+export * from "./parse.ts";
+export * from "./serialize.ts";

package/src/semantic/metadata.ts

@@ -0,0 +1,37 @@
+import type { PointSemanticDeclarationMetadata } from "../core/ast.ts";
+import type { PointSemanticDeclaration } from "./ast.ts";
+
+export function semanticDeclarationMetadata(declaration: PointSemanticDeclaration): PointSemanticDeclarationMetadata {
+	if (declaration.kind === "record") {
+		return { kind: "record", name: declaration.name, outputName: undefined, effects: undefined };
+	}
+	if (declaration.kind === "external") {
+		return { kind: "external", name: declaration.name, outputName: undefined, effects: undefined };
+	}
+	if (declaration.kind === "calculation" || declaration.kind === "rule" || declaration.kind === "action" || declaration.kind === "workflow" || declaration.kind === "command") {
+		return {
+			kind: declaration.kind,
+			name: declaration.name,
+			outputName: declaration.output.name,
+			effects: declaration.kind === "action" ? declaration.touches : [],
+		};
+	}
+	if (declaration.kind === "label") {
+		return { kind: "label", name: declaration.name, outputName: declaration.output.name, effects: [] };
+	}
+	if (declaration.kind === "policy") {
+		return { kind: "policy", name: declaration.name, outputName: "policy", effects: [] };
+	}
+	if (declaration.kind === "view") {
+		return {
+			kind: "view",
+			name: declaration.name,
+			outputName: declaration.output.name === "page" ? "view" : declaration.output.name,
+			effects: [],
+		};
+	}
+	if (declaration.kind === "route") {
+		return { kind: "route", name: declaration.name, outputName: declaration.output.name, effects: [] };
+	}
+	throw new Error(`Unsupported semantic metadata for ${declaration.kind}`);
+}

package/src/semantic/naming.ts

@@ -0,0 +1,33 @@
+export function toPascalCase(label: string): string {
+	const words = label.match(/[A-Za-z0-9]+/g) ?? [];
+	return words.map((word) => `${word.slice(0, 1).toUpperCase()}${word.slice(1)}`).join("");
+}
+
+export function toIdentifier(label: string): string {
+	const words = label.match(/[A-Za-z0-9]+/g) ?? [];
+	return words.map((word, index) => (index === 0 ? word.toLowerCase() : toPascalCase(word))).join("");
+}
+
+export function semanticFunctionName(
+	label: string,
+	outputName: string,
+	kind: "calculation" | "rule" | "label" | "action" | "policy" | "view" | "route" | "workflow" | "command",
+): string {
+	const base = toIdentifier(label);
+	const suffix =
+		kind === "label"
+			? "Label"
+			: kind === "policy"
+				? "Policy"
+				: kind === "view"
+					? "View"
+					: kind === "route"
+						? "Route"
+						: kind === "workflow"
+							? "Workflow"
+							: kind === "command"
+								? "Command"
+								: toPascalCase(outputName);
+	if (!suffix) return base;
+	return base.toLowerCase().endsWith(suffix.toLowerCase()) ? base : `${base}${suffix}`;
+}