@hatchingpoint/point 0.0.11 → 0.0.13

package/src/core/emit-python.ts

@@ -0,0 +1,188 @@
+import type {
+	PointCoreDeclaration,
+	PointCoreExpression,
+	PointCoreExternalDeclaration,
+	PointCoreFunctionDeclaration,
+	PointCoreParameter,
+	PointCorePrimitiveType,
+	PointCoreProgram,
+	PointCoreStatement,
+	PointCoreTypeDeclaration,
+	PointCoreTypeExpression,
+	PointCoreValueDeclaration,
+} from "./ast.ts";
+
+const BINARY_OPERATORS: Record<string, string> = {
+	and: "and",
+	or: "or",
+};
+
+const UNSUPPORTED_SEMANTIC_KINDS = new Set(["view", "page", "route", "workflow", "command"]);
+
+/** True when every declaration is emit-able as Python (no views, routes, workflows, or commands). */
+export function isPureLogicProgram(program: PointCoreProgram): boolean {
+	return !program.declarations.some((declaration) => declaration.semantic && UNSUPPORTED_SEMANTIC_KINDS.has(declaration.semantic.kind));
+}
+
+/** Emit Python from a core AST program (pure logic modules). Production path: parsePointSource → check → emit. */
+export function emitPointCorePython(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("");
+	lines.push("from __future__ import annotations");
+	lines.push("");
+	if (program.declarations.some((declaration) => declaration.kind === "type")) {
+		lines.push("from typing import TypedDict");
+		lines.push("");
+	}
+	for (const declaration of program.declarations) {
+		const emitted = emitDeclaration(declaration);
+		if (emitted.length > 0) lines.push(...emitted, "");
+	}
+	return `${trimTrailingBlankLines(lines).join("\n")}\n`;
+}
+
+function emitDeclaration(declaration: PointCoreDeclaration): string[] {
+	if (declaration.kind === "import") {
+		const moduleName = declaration.from.replace(/^\.\//, "").replace(/-/g, "_");
+		return [`from ${toPythonModuleName(moduleName)} import ${declaration.names.join(", ")}`];
+	}
+	if (declaration.kind === "external") return emitExternal(declaration);
+	if (declaration.kind === "type") return emitType(declaration);
+	if (declaration.kind === "value") return [emitValue(declaration)];
+	if (declaration.semantic && UNSUPPORTED_SEMANTIC_KINDS.has(declaration.semantic.kind)) {
+		return [`# Point: ${declaration.semantic.kind} blocks are not supported in Python emit yet`];
+	}
+	return emitFunction(declaration);
+}
+
+function emitType(declaration: PointCoreTypeDeclaration): string[] {
+	return [
+		`class ${declaration.name}(TypedDict):`,
+		...declaration.fields.map((field) => `    ${field.name}: ${emitTypeExpression(field.type)}`),
+	];
+}
+
+function emitExternal(declaration: PointCoreExternalDeclaration): string[] {
+	if (declaration.from === "node:fs" && declaration.importName === "readFileSync") {
+		return [
+			`def ${declaration.name}(${declaration.params.map(emitParam).join(", ")}) -> ${emitTypeExpression(declaration.returnType)}:`,
+			"    from pathlib import Path",
+			"    return Path(path).read_text()",
+		];
+	}
+	const moduleName = declaration.from.replace(/^\.\//, "").replace(/-/g, "_");
+	const imported = declaration.importName ?? declaration.name;
+	return [`from ${toPythonModuleName(moduleName)} import ${imported} as ${declaration.name}`];
+}
+
+function emitFunction(declaration: PointCoreFunctionDeclaration): string[] {
+	const asyncPrefix = declaration.semantic?.kind === "action" || declaration.semantic?.kind === "workflow" || declaration.semantic?.kind === "command" ? "async " : "";
+	return [
+		`${asyncPrefix}def ${declaration.name}(${declaration.params.map(emitParam).join(", ")}) -> ${emitReturnType(declaration)}:`,
+		...indentLines(declaration.body.flatMap((statement) => emitStatement(statement, declaration.semantic?.kind))),
+	];
+}
+
+function emitReturnType(declaration: PointCoreFunctionDeclaration): string {
+	if (declaration.semantic?.kind === "action" || declaration.semantic?.kind === "workflow" || declaration.semantic?.kind === "command") {
+		return emitTypeExpression(declaration.returnType);
+	}
+	return emitTypeExpression(declaration.returnType);
+}
+
+function emitStatement(statement: PointCoreStatement, semanticKind?: string): string[] {
+	if (statement.kind === "return") {
+		if (semanticKind === "view" || semanticKind === "page") return ["# Point: view/page return values are not supported in Python emit yet", "return \"\""];
+		return [statement.value ? `return ${emitExpression(statement.value)}` : "return"];
+	}
+	if (statement.kind === "value") return [emitValue(statement)];
+	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 ${statement.itemName} in ${emitExpression(statement.iterable)}:`, ...indentLines(statement.body.flatMap((child) => emitStatement(child, semanticKind)))];
+	}
+	return [emitExpression(statement.value)];
+}
+
+function emitValue(declaration: PointCoreValueDeclaration): string {
+	return `${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 `list[${type.args[0] ? emitTypeExpression(type.args[0]) : "object"}]`;
+	if (type.name === "Maybe") return `${type.args[0] ? emitTypeExpression(type.args[0]) : "object"} | None`;
+	if (type.name === "Or") return type.args.map(emitTypeExpression).join(" | ");
+	if (type.name === "Error") return "dict[str, str]";
+	if (isPrimitiveType(type.name)) return emitPrimitiveType(type.name);
+	return type.name;
+}
+
+function emitPrimitiveType(type: PointCorePrimitiveType): string {
+	if (type === "Text") return "str";
+	if (type === "Int") return "int";
+	if (type === "Float") return "float";
+	if (type === "Bool") return "bool";
+	return "None";
+}
+
+function emitExpression(expression: PointCoreExpression): string {
+	if (expression.kind === "literal") return emitLiteral(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)}[${JSON.stringify(expression.name)}]`;
+	if (expression.kind === "call") {
+		if (expression.callee === "Error") {
+			const message = expression.args[0] ? emitExpression(expression.args[0]) : '""';
+			return `{"message": ${message}}`;
+		}
+		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 emitLiteral(value: unknown): string {
+	if (value === null) return "None";
+	if (value === true) return "True";
+	if (value === false) return "False";
+	if (typeof value === "string") return JSON.stringify(value);
+	return String(value);
+}
+
+function emitCondition(expression: PointCoreExpression): string {
+	const emitted = emitExpression(expression);
+	return emitted.startsWith("(") && emitted.endsWith(")") ? emitted.slice(1, -1) : emitted;
+}
+
+function toPythonModuleName(from: string): string {
+	return from.replace(/\.ts$/, "").replace(/\.js$/, "").replace(/\.py$/, "");
+}
+
+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/emit-typescript.ts

@@ -9,6 +9,9 @@ import type {
 	PointCoreTypeDeclaration,
 	PointCoreTypeExpression,
 	PointCoreValueDeclaration,
+	PointSemanticPageLayout,
+	PointSemanticViewCheckboxBinding,
+	PointSemanticViewControls,
 } from "./ast.ts";
 
 const BINARY_OPERATORS: Record<string, string> = {
@@ -54,22 +57,93 @@ function emitFunction(declaration: PointCoreFunctionDeclaration): string[] {
 	const returnType =
 		declaration.semantic?.kind === "action" || declaration.semantic?.kind === "workflow" || declaration.semantic?.kind === "command"
 			? `Promise<${emitTypeExpression(declaration.returnType)}>`
-			: declaration.semantic?.kind === "view"
+			: declaration.semantic?.kind === "view" || declaration.semantic?.kind === "page"
 				? "JSX.Element"
 				: declaration.semantic?.kind === "route"
 					? "Response | string"
 				: emitTypeExpression(declaration.returnType);
+	const viewControls = declaration.semantic?.viewControls;
+	const bodyLines =
+		declaration.semantic?.kind === "page" && declaration.semantic.pageLayout
+			? emitPageBody(declaration.semantic.pageLayout)
+			: declaration.semantic?.kind === "view" && viewControls
+				? emitControlledViewBody(declaration.body, viewControls)
+				: declaration.body.flatMap((statement) => emitStatement(statement, declaration.semantic?.kind));
 	return [
 		`export ${asyncPrefix}function ${declaration.name}(${declaration.params.map(emitParam).join(", ")}): ${returnType} {`,
-		...indentLines(declaration.body.flatMap((statement) => emitStatement(statement, declaration.semantic?.kind))),
+		...indentLines(bodyLines),
 		"}",
 	];
 }
 
+function emitControlledViewBody(body: PointCoreStatement[], controls: PointSemanticViewControls): string[] {
+	const checkboxLines = controls.checkboxes.map((binding) => emitCheckboxControl(binding, controls.changeCallback));
+	const contentJsx = emitViewContentExpression(body);
+	return ["return (", "  <>", ...indentLines(checkboxLines), `    ${contentJsx}`, "  </>", ");"];
+}
+
+function emitCheckboxControl(binding: PointSemanticViewCheckboxBinding, changeCallback: string): string {
+	const checked = emitExpression(binding.target);
+	return `<label><input type="checkbox" checked={${checked}} onChange={(e) => ${changeCallback}({ ...${binding.recordParam}, ${binding.fieldName}: e.target.checked })} />${escapeJsxText(binding.label)}</label>`;
+}
+
+function emitViewContentExpression(body: PointCoreStatement[]): string {
+	let expression = "null";
+	for (let index = body.length - 1; index >= 0; index -= 1) {
+		const statement = body[index];
+		if (!statement) continue;
+		if (statement.kind === "return" && statement.value) {
+			expression = emitViewRenderFragment(statement.value);
+			continue;
+		}
+		if (statement.kind === "if" && statement.thenBody.length === 1 && statement.thenBody[0]?.kind === "return" && statement.thenBody[0].value) {
+			const thenValue = emitViewRenderFragment(statement.thenBody[0].value);
+			expression = `${emitCondition(statement.condition)} ? ${thenValue} : ${expression}`;
+		}
+	}
+	return `{${expression}}`;
+}
+
+function emitViewRenderFragment(expression: PointCoreExpression): string {
+	if (expression.kind === "literal" && typeof expression.value === "string") {
+		return `<>${escapeJsxText(expression.value)}</>`;
+	}
+	return `<>{${emitExpression(expression)}}</>`;
+}
+
+function emitPageBody(layout: PointSemanticPageLayout): string[] {
+	const title = emitJsxChild(layout.title);
+	const description = layout.description ? `\n      <p className="point-page-description">${emitJsxChild(layout.description)}</p>` : "";
+	const main = emitJsxChild(layout.main, true);
+	return [
+		`return (`,
+		`  <main className="point-page">`,
+		`    <header className="point-page-header">`,
+		`      <h1>${title}</h1>${description}`,
+		`    </header>`,
+		`    <section className="point-page-main">${main}</section>`,
+		`  </main>`,
+		`);`,
+	];
+}
+
+function emitJsxChild(expression: PointCoreExpression, allowComponent = false): string {
+	if (expression.kind === "literal" && typeof expression.value === "string") {
+		return escapeJsxText(expression.value);
+	}
+	if (allowComponent) {
+		return `{${emitExpression(expression)}}`;
+	}
+	return `{${emitExpression(expression)}}`;
+}
+
 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)}</>;`];
+		if (semanticKind === "view" && statement.value) {
+			if (statement.value.kind === "literal" && typeof statement.value.value === "string") {
+				return [`return <>${escapeJsxText(statement.value.value)}</>;`];
+			}
+			return [`return <>{${emitExpression(statement.value)}}</>;`];
 		}
 		return [statement.value ? `return ${emitExpression(statement.value)};` : "return;"];
 	}
@@ -111,10 +185,20 @@ function emitValue(declaration: PointCoreValueDeclaration, exported: boolean): s
 }
 
 function emitParam(param: PointCoreParameter): string {
-	return `${param.name}: ${emitTypeExpression(param.type)}`;
+	return `${param.name}: ${emitParamType(param.type)}`;
+}
+
+function emitParamType(type: PointCoreTypeExpression): string {
+	if (type.name === "Handler" && type.args.length === 1) {
+		return `(value: ${emitTypeExpression(type.args[0]!)}) => void`;
+	}
+	return emitTypeExpression(type);
 }
 
 function emitTypeExpression(type: PointCoreTypeExpression): string {
+	if (type.name === "Handler" && type.args.length === 1) {
+		return `(value: ${emitTypeExpression(type.args[0]!)}) => void`;
+	}
 	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(" | ");

package/src/core/index.ts

@@ -1,10 +1,13 @@
 export * from "./ast.ts";
 export * from "./check.ts";
 export { findRunEntryName } from "./cli.ts";
+export * from "./check-docs.ts";
 export * from "./context.ts";
 export * from "./emit-typescript.ts";
 export * from "./emit-javascript.ts";
+export * from "./emit-python.ts";
 export * from "./incremental.ts";
+export * from "./packages.ts";
 export * from "./serialize.ts";
 export * from "../semantic/index.ts";
 export * from "./format.ts";

package/src/core/packages.ts

@@ -0,0 +1,138 @@
+import { existsSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+
+export const POINT_MANIFEST = "point.json";
+export const POINT_LOCK = "point.lock";
+export const LOCK_SCHEMA = "point.lock.v1";
+
+export interface PointManifest {
+	name: string;
+	version: string;
+	dependencies?: Record<string, string>;
+}
+
+export interface PointLock {
+	schemaVersion: typeof LOCK_SCHEMA;
+	packages: Record<string, PointLockPackage>;
+}
+
+export interface PointLockPackage {
+	version: string;
+	path?: string;
+	dependencies?: Record<string, string>;
+}
+
+export type DependencySpecKind = "workspace" | "file" | "npm";
+
+export interface ParsedDependencySpec {
+	kind: DependencySpecKind;
+	locator: string;
+}
+
+export function parseDependencySpec(spec: string): ParsedDependencySpec {
+	if (spec.startsWith("workspace:")) return { kind: "workspace", locator: spec.slice("workspace:".length) };
+	if (spec.startsWith("file:")) return { kind: "file", locator: spec.slice("file:".length) };
+	if (spec.startsWith("npm:")) return { kind: "npm", locator: spec.slice("npm:".length) };
+	throw new Error(`Invalid dependency spec "${spec}". Use workspace:<path>, file:<path>, or npm:<package> (npm not yet supported).`);
+}
+
+export function npmDependencyNotSupportedMessage(spec: string): string {
+	return `npm: registry dependencies are not supported yet (${spec}). Use workspace:<path> or file:<path> for local Point packages.`;
+}
+
+export async function readPointManifest(cwd = process.cwd()): Promise<PointManifest> {
+	const path = join(cwd, POINT_MANIFEST);
+	if (!existsSync(path)) throw new Error(`Missing ${POINT_MANIFEST} in ${cwd}`);
+	return Bun.file(path).json() as Promise<PointManifest>;
+}
+
+export async function writePointManifest(manifest: PointManifest, cwd = process.cwd()): Promise<void> {
+	const path = join(cwd, POINT_MANIFEST);
+	await Bun.write(path, `${JSON.stringify(manifest, null, 2)}\n`);
+}
+
+export async function readPointLock(cwd = process.cwd()): Promise<PointLock | null> {
+	const path = join(cwd, POINT_LOCK);
+	if (!existsSync(path)) return null;
+	const lock = (await Bun.file(path).json()) as PointLock;
+	if (lock.schemaVersion !== LOCK_SCHEMA) {
+		throw new Error(`Unsupported ${POINT_LOCK} schema: ${lock.schemaVersion}`);
+	}
+	return lock;
+}
+
+export async function writePointLock(lock: PointLock, cwd = process.cwd()): Promise<void> {
+	const path = join(cwd, POINT_LOCK);
+	await Bun.write(path, `${JSON.stringify(lock, null, 2)}\n`);
+}
+
+export function normalizePackagePath(cwd: string, rawPath: string): string {
+	const absolute = resolve(cwd, rawPath);
+	if (!existsSync(absolute)) {
+		throw new Error(`Dependency path does not exist: ${rawPath}`);
+	}
+	return relative(cwd, absolute).split("\\").join("/") || ".";
+}
+
+export function resolveDependencySpec(spec: string, cwd = process.cwd()): PointLockPackage {
+	const parsed = parseDependencySpec(spec);
+	if (parsed.kind === "npm") throw new Error(npmDependencyNotSupportedMessage(spec));
+	const path = normalizePackagePath(cwd, parsed.locator);
+	return { version: parsed.kind, path };
+}
+
+export async function resolveLockFromManifest(manifest: PointManifest, cwd = process.cwd()): Promise<PointLock> {
+	const packages: Record<string, PointLockPackage> = {
+		[manifest.name]: {
+			version: manifest.version,
+			dependencies: manifest.dependencies ?? {},
+		},
+	};
+	for (const [name, spec] of Object.entries(manifest.dependencies ?? {})) {
+		packages[name] = resolveDependencySpec(spec, cwd);
+		const entry = packages[name];
+		if (!entry.path) continue;
+		const nestedManifestPath = join(cwd, entry.path, POINT_MANIFEST);
+		if (!existsSync(nestedManifestPath)) continue;
+		const nested = (await Bun.file(nestedManifestPath).json()) as PointManifest;
+		packages[nested.name] = {
+			version: nested.version,
+			dependencies: nested.dependencies ?? {},
+		};
+	}
+	return { schemaVersion: LOCK_SCHEMA, packages };
+}
+
+export async function addPointDependency(name: string, spec: string, cwd = process.cwd()): Promise<{ manifest: PointManifest; lock: PointLock }> {
+	if (!name || !/^[A-Za-z][A-Za-z0-9_-]*$/.test(name)) {
+		throw new Error(`Invalid dependency name "${name}". Use an identifier like std or point-logic.`);
+	}
+	parseDependencySpec(spec);
+	const manifest = await readPointManifest(cwd);
+	manifest.dependencies = { ...(manifest.dependencies ?? {}), [name]: spec };
+	const lock = await resolveLockFromManifest(manifest, cwd);
+	await writePointManifest(manifest, cwd);
+	await writePointLock(lock, cwd);
+	return { manifest, lock };
+}
+
+export function packageRootFromLock(lock: PointLock | null, packageName: string): string | null {
+	const entry = lock?.packages[packageName];
+	if (entry?.path) return entry.path;
+	if (!lock && packageName === "std") return "std";
+	return null;
+}
+
+export function modulePathFromLock(lock: PointLock | null, moduleName: string): string {
+	const dot = moduleName.indexOf(".");
+	if (dot < 0) {
+		throw new Error(`Use declarations without from must target package modules: ${moduleName}`);
+	}
+	const packageName = moduleName.slice(0, dot);
+	const modulePath = moduleName.slice(dot + 1);
+	const root = packageRootFromLock(lock, packageName);
+	if (!root) {
+		throw new Error(`Unknown package "${packageName}" in ${moduleName}. Add it with: point add ${packageName} <spec>`);
+	}
+	return `${root}/${modulePath.replaceAll(".", "/")}.point`;
+}

package/src/core/semantic-source.ts

@@ -1,7 +1,7 @@
 export function isSemanticPointSyntax(source: string): boolean {
 	return source
 		.split(/\r?\n/)
-		.some((line) => /^(use|record|calculation|rule|label|external|action|policy|view|route|workflow|command)\s+/.test(line.trim()));
+		.some((line) => /^(use|record|calculation|rule|label|external|action|policy|view|page|route|workflow|command)\s+/.test(line.trim()));
 }
 
 export function assertSemanticPointSource(source: string) {
@@ -12,7 +12,7 @@ export function assertSemanticPointSource(source: string) {
 	for (const [index, line] of lines.entries()) {
 		const trimmed = line.trim();
 		if (!trimmed || trimmed.startsWith("//")) continue;
-		if (/^(record|calculation|rule|label|external|action|policy|view|route|workflow|command)\s+/.test(trimmed)) hasSemanticDeclaration = true;
+		if (/^(record|calculation|rule|label|external|action|policy|view|page|route|workflow|command)\s+/.test(trimmed)) hasSemanticDeclaration = true;
 		if (oldStyleTopLevel.test(trimmed)) {
 			throw new Error(
 				`Point source uses internal core syntax at ${index + 1}:1. Use record, calculation, rule, or label instead.`,

package/src/core/test-only/legacy-lowering.ts

@@ -1,5 +1,7 @@
 import type { PointCoreProgram } from "../ast.ts";
 import { assertSemanticPointSource, isSemanticPointSyntax } from "../semantic-source.ts";
+import { desugarSemanticProgram } from "../../semantic/desugar.ts";
+import { parseSemanticSource } from "../../semantic/parse.ts";
 import { parsePointCore } from "./core-text-parser.ts";
 
 /** Legacy string-lowering path retained for migration parity tests only. */
@@ -11,10 +13,27 @@ export function parsePointSourceLegacy(source: string): PointCoreProgram {
 function parsePointSourceViaLowering(source: string): PointCoreProgram {
 	const lowered = lowerSemanticPointSyntax(source);
 	const program = parsePointCore(lowered);
-	if (isSemanticPointSyntax(source)) attachSemanticMetadata(program, source);
+	if (isSemanticPointSyntax(source)) {
+		attachSemanticMetadata(program, source);
+		enrichPageLayouts(program, source);
+	}
 	return program;
 }
 
+function enrichPageLayouts(program: PointCoreProgram, source: string): void {
+	const desugared = desugarSemanticProgram(parseSemanticSource(source));
+	const pageFunctions = desugared.declarations.filter(
+		(declaration): declaration is Extract<(typeof desugared.declarations)[number], { kind: "function" }> =>
+			declaration.kind === "function" && declaration.semantic?.kind === "page",
+	);
+	for (const declaration of program.declarations) {
+		if (declaration.kind !== "function" || declaration.semantic?.kind !== "page") continue;
+		const match = pageFunctions.find((candidate) => candidate.name === declaration.name);
+		if (!match?.semantic?.pageLayout) continue;
+		declaration.semantic.pageLayout = match.semantic.pageLayout;
+	}
+}
+
 function lowerSemanticPointSyntax(source: string): string {
 	if (!isSemanticPointSyntax(source)) return source;
 	const lines = source.split(/\r?\n/);
@@ -87,6 +106,12 @@ function lowerSemanticPointSyntax(source: string): string {
 			index = lowered.next;
 			continue;
 		}
+		if (trimmed.startsWith("page ")) {
+			const lowered = lowerPage(lines, index, records, externalBindings);
+			output.push(...lowered.lines);
+			index = lowered.next;
+			continue;
+		}
 		if (trimmed.startsWith("route ")) {
 			const lowered = lowerRoute(lines, index, records, externalBindings);
 			output.push(...lowered.lines);
@@ -120,7 +145,7 @@ function assertSemanticPointSource(source: string) {
 	for (const [index, line] of lines.entries()) {
 		const trimmed = line.trim();
 		if (!trimmed || trimmed.startsWith("//")) continue;
-		if (/^(record|calculation|rule|label|external|action|policy|view|route|workflow|command)\s+/.test(trimmed)) hasSemanticDeclaration = true;
+		if (/^(record|calculation|rule|label|external|action|policy|view|page|route|workflow|command)\s+/.test(trimmed)) hasSemanticDeclaration = true;
 		if (oldStyleTopLevel.test(trimmed)) {
 			throw new Error(
 				`Point source uses internal core syntax at ${index + 1}:1. Use record, calculation, rule, or label instead.`,
@@ -534,6 +559,44 @@ function lowerView(
 	};
 }
 
+function lowerPage(
+	lines: string[],
+	start: number,
+	records: Map<string, Map<string, string>>,
+	externalBindings: Map<string, string> = new Map(),
+): { lines: string[]; next: number } {
+	const label = (lines[start] ?? "").trim().slice("page ".length).trim();
+	const body = collectSemanticBody(lines, start + 1);
+	const params: string[] = [];
+	const paramTypes = new Map<string, string>();
+	const bindings = new Map<string, string>(externalBindings);
+	let mainExpression: string | undefined;
+
+	for (const line of body.lines) {
+		if (line.startsWith("input ")) {
+			const param = parseTypedBinding(line.slice("input ".length));
+			const paramName = toIdentifier(param.name);
+			params.push(`${paramName}: ${param.type}`);
+			paramTypes.set(paramName, param.type);
+			bindings.set(param.name, paramName);
+			continue;
+		}
+		if (line.startsWith("title ") || line.startsWith("description ")) continue;
+		if (line.startsWith("main render ")) {
+			mainExpression = lowerExpression(line.slice("main render ".length), paramTypes, records, bindings);
+			continue;
+		}
+		throw new Error(`Unknown page statement: ${line}`);
+	}
+
+	if (!mainExpression) throw new Error(`Page ${label} requires main render`);
+
+	return {
+		lines: [`fn ${semanticFunctionName(label, "page", "page")}(${params.join(", ")}): Text {`, `  return ${mainExpression}`, "}", ""],
+		next: body.next,
+	};
+}
+
 function lowerRoute(
 	lines: string[],
 	start: number,
@@ -745,6 +808,7 @@ function collectSemanticDeclarationInfo(source: string): SemanticDeclarationInfo
 			trimmed.startsWith("action ") ||
 			trimmed.startsWith("policy ") ||
 			trimmed.startsWith("view ") ||
+			trimmed.startsWith("page ") ||
 			trimmed.startsWith("route ") ||
 			trimmed.startsWith("workflow ") ||
 			trimmed.startsWith("command ")
@@ -761,7 +825,9 @@ function collectSemanticDeclarationInfo(source: string): SemanticDeclarationInfo
 								? "policy"
 								: trimmed.startsWith("view ")
 									? "view"
-									: trimmed.startsWith("route ")
+									: trimmed.startsWith("page ")
+										? "page"
+										: trimmed.startsWith("route ")
 										? "route"
 										: trimmed.startsWith("workflow ")
 											? "workflow"
@@ -771,7 +837,7 @@ function collectSemanticDeclarationInfo(source: string): SemanticDeclarationInfo
 			const body = collectSemanticBody(lines, index + 1);
 			const params = new Map<string, string>();
 			let outputName =
-				kind === "label" ? "label" : kind === "policy" ? "policy" : kind === "view" ? "view" : kind === "route" ? "route" : "result";
+				kind === "label" ? "label" : kind === "policy" ? "policy" : kind === "view" ? "view" : kind === "page" ? "page" : kind === "route" ? "route" : "result";
 			const effects: string[] = [];
 			for (const line of body.lines) {
 				if (line.startsWith("input ")) {
@@ -840,6 +906,7 @@ function collectCallableBindings(source: string): Map<string, string> {
 			declaration.kind === "action" ||
 			declaration.kind === "policy" ||
 			declaration.kind === "view" ||
+			declaration.kind === "page" ||
 			declaration.kind === "route" ||
 			declaration.kind === "workflow" ||
 			declaration.kind === "command"
@@ -870,7 +937,7 @@ function collectSemanticBody(lines: string[], start: number): { lines: string[];
 }
 
 function isSemanticTopLevel(line: string): boolean {
-	return /^(module|use|record|calculation|rule|label|external|action|policy|view|route|workflow|command|type|fn|let|var|import)\s+/.test(line);
+	return /^(module|use|record|calculation|rule|label|external|action|policy|view|page|route|workflow|command|type|fn|let|var|import)\s+/.test(line);
 }
 
 function isSemanticLoopBoundary(line: string): boolean {
@@ -973,7 +1040,7 @@ function toIdentifier(label: string): string {
 function semanticFunctionName(
 	label: string,
 	outputName: string,
-	kind: "calculation" | "rule" | "label" | "action" | "policy" | "view" | "route" | "workflow" | "command",
+	kind: "calculation" | "rule" | "label" | "action" | "policy" | "view" | "page" | "route" | "workflow" | "command",
 ): string {
 	const base = toIdentifier(label);
 	const suffix =
@@ -983,7 +1050,9 @@ function semanticFunctionName(
 				? "Policy"
 				: kind === "view"
 					? "View"
-					: kind === "route"
+					: kind === "page"
+						? "Page"
+						: kind === "route"
 						? "Route"
 						: kind === "workflow"
 							? "Workflow"