@hatchingpoint/point 0.0.12 → 0.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchingpoint/point",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "private": false,
   "type": "module",
   "description": "Point language compiler and CLI.",
@@ -24,7 +24,9 @@
   "exports": {
     ".": "./src/index.ts",
     "./cli": "./src/cli.ts",
-    "./core": "./src/core/index.ts"
+    "./core": "./src/core/index.ts",
+    "./std/json": "./src/std/json.ts",
+    "./std/http": "./src/std/http.ts"
   },
   "publishConfig": {
     "access": "public",

package/src/core/ast.ts

@@ -85,11 +85,31 @@ export interface PointSemanticProgramMetadata {
 	source: "semantic";
 }
 
+export interface PointSemanticPageLayout {
+	title: PointCoreExpression;
+	description?: PointCoreExpression;
+	main: PointCoreExpression;
+}
+
+export interface PointSemanticViewCheckboxBinding {
+	label: string;
+	target: PointCoreExpression;
+	recordParam: string;
+	fieldName: string;
+}
+
+export interface PointSemanticViewControls {
+	changeCallback: string;
+	checkboxes: PointSemanticViewCheckboxBinding[];
+}
+
 export interface PointSemanticDeclarationMetadata {
-	kind: "record" | "calculation" | "rule" | "label" | "external" | "action" | "policy" | "view" | "route" | "workflow" | "command";
+	kind: "record" | "calculation" | "rule" | "label" | "external" | "action" | "policy" | "view" | "page" | "route" | "workflow" | "command";
 	name: string;
 	outputName?: string;
 	effects?: string[];
+	pageLayout?: PointSemanticPageLayout;
+	viewControls?: PointSemanticViewControls;
 }
 
 export interface PointCoreTypeExpression {

package/src/core/check.ts

@@ -28,7 +28,7 @@ type DiagnosticMetadata = Partial<Pick<PointCoreDiagnostic, "expected" | "actual
 type ScopeEntry = { type: PointCoreTypeExpression; mutable: boolean };
 type Scope = Map<string, ScopeEntry>;
 
-const PRIMITIVE_TYPES = new Set(["Text", "Int", "Float", "Bool", "Void", "List", "Maybe", "Error", "Or"]);
+const PRIMITIVE_TYPES = new Set(["Text", "Int", "Float", "Bool", "Void", "List", "Maybe", "Error", "Or", "Page", "Handler"]);
 
 export function checkPointCore(program: PointCoreProgram): PointCoreDiagnostic[] {
 	const checker = new CoreChecker(program);
@@ -125,6 +125,7 @@ class CoreChecker {
 				}
 				return;
 			}
+			if (fn.semantic?.kind === "page" || fn.semantic?.kind === "view") return;
 			this.checkExpressionAssignable(statement.value, fn.returnType, `fn.${fn.name}.return`, locals);
 			return;
 		}
@@ -531,7 +532,14 @@ class CoreChecker {
 				repair: "Use syntax such as User or Error.",
 			});
 		}
-		if (type.name !== "List" && type.name !== "Maybe" && type.name !== "Or" && type.args.length > 0 && !this.typeDeclarations.has(String(type.name))) {
+		if (type.name === "Handler" && type.args.length !== 1) {
+			this.push("invalid-type-arity", "Handler requires one type argument", path, type.span, {
+				expected: "Handler T",
+				actual: formatType(type),
+				repair: "Use Handler Listing Signals or another record type.",
+			});
+		}
+		if (type.name !== "List" && type.name !== "Maybe" && type.name !== "Or" && type.name !== "Handler" && type.args.length > 0 && !this.typeDeclarations.has(String(type.name))) {
 			this.push("invalid-type-arity", `${type.name} does not accept type arguments`, path, type.span, {
 				expected: String(type.name),
 				actual: formatType(type),

package/src/core/cli.ts

@@ -6,11 +6,12 @@ import { createPointCoreIndex, createPointCoreRepairPlan, explainPointCoreRef }
 import { createSemanticIndex, explainSemanticRef, mapPublicDiagnostics } from "../semantic/context.ts";
 import { emitPointCoreTypeScript } from "./emit-typescript.ts";
 import { emitPointCoreJavaScript } from "./emit-javascript.ts";
-import { emitPointCorePython } from "./emit-python.ts";
+import { emitPointCorePython, isPureLogicProgram } from "./emit-python.ts";
 import { formatPointSource } from "./format.ts";
 import { isCacheHit, isIncrementalEnabled, readBuildCache, recordCacheEntry, writeBuildCache } from "./incremental.ts";
 import { parsePointSource } from "./parser.ts";
 import { runCheckDocs } from "./check-docs.ts";
+import { addPointDependency, modulePathFromLock, POINT_LOCK, POINT_MANIFEST, readPointLock } from "./packages.ts";
 import { runPointLspServer } from "../lsp/server.ts";
 
 const DEFAULT_INPUT = "examples/math.point";
@@ -43,6 +44,18 @@ export async function main() {
 		return;
 	}
 
+	if (command === "add") {
+		const dependencyName = input;
+		const spec = output;
+		if (!dependencyName || !spec) {
+			throw new Error("Usage: point add <name> <spec>  (spec: workspace:<path> | file:<path> | npm:<package>)");
+		}
+		const { manifest, lock } = await addPointDependency(dependencyName, spec);
+		console.log(`Point add updated ${POINT_MANIFEST} and ${POINT_LOCK}: ${dependencyName} -> ${spec}`);
+		console.log(JSON.stringify({ name: manifest.name, dependencies: manifest.dependencies, lockPackages: Object.keys(lock.packages) }, null, 2));
+		return;
+	}
+
 	const inputPath = resolve(process.cwd(), input);
 	const source = await Bun.file(inputPath).text();
 	const program = parsePointSource(source);
@@ -198,8 +211,9 @@ export async function main() {
 async function runProjectCommand(command: string) {
 	const inputs = await discoverInputs();
 	if (inputs.length === 0) throw new Error(`No Point core files matched ${DEFAULT_PATTERNS.join(", ")}`);
-	const results = await Promise.all(inputs.map((input) => loadCoreFile(input)));
-	const graph = createModuleGraph(results);
+	const lock = await readPointLock();
+	const results = await Promise.all(inputs.map((input) => loadCoreFile(input, lock)));
+	const graph = createModuleGraph(results, lock);
 	const orderedResults = orderByDependencies(results, graph);
 
 	if (command === "fmt-all") {
@@ -298,6 +312,26 @@ async function runProjectCommand(command: string) {
 		return;
 	}
 
+	if (command === "build-py-all") {
+		const diagnostics = orderedResults.flatMap((result) =>
+			checkPointCore(programWithDependencyDeclarations(result, graph)).map((diagnostic) => ({ ...diagnostic, file: result.input })),
+		);
+		if (diagnostics.length > 0) {
+			console.error(JSON.stringify({ ok: false, diagnostics }, null, 2));
+			process.exit(1);
+		}
+		const pureLogicResults = orderedResults.filter((result) => isPureLogicProgram(result.program));
+		for (const result of pureLogicResults) {
+			const output = pyOutputFor(result.input);
+			const outputPath = resolve(process.cwd(), output);
+			await Bun.$`mkdir -p ${dirname(outputPath)}`.quiet();
+			await Bun.write(outputPath, emitPointCorePython(programWithTypeScriptImports(result, graph)));
+		}
+		const skipped = results.length - pureLogicResults.length;
+		console.log(`Point core Python build wrote ${pureLogicResults.length} files${skipped ? ` (${skipped} skipped)` : ""}`);
+		return;
+	}
+
 	if (command === "test-all") {
 		const diagnostics = orderedResults.flatMap((result) =>
 			checkPointCore(programWithDependencyDeclarations(result, graph)).map((diagnostic) => ({ ...diagnostic, file: result.input })),
@@ -409,9 +443,9 @@ export function findRunEntryName(program: PointCoreProgram): string | null {
 	return preferred?.name ?? null;
 }
 
-async function loadCoreFile(input: string) {
+async function loadCoreFile(input: string, lock: Awaited<ReturnType<typeof readPointLock>>) {
 	const source = await Bun.file(resolve(process.cwd(), input)).text();
-	return { input, source, program: parsePointSource(source), uses: parseUseDeclarations(source, input) };
+	return { input, source, program: parsePointSource(source), uses: parseUseDeclarations(source, input, lock) };
 }
 
 type CoreFile = Awaited<ReturnType<typeof loadCoreFile>>;
@@ -423,15 +457,15 @@ interface UseDeclaration {
 	input: string;
 }
 
-function parseUseDeclarations(source: string, input: string): UseDeclaration[] {
+function parseUseDeclarations(source: string, input: string, lock: Awaited<ReturnType<typeof readPointLock>>): UseDeclaration[] {
 	return source
 		.split(/\r?\n/)
 		.map((line) => line.trim().match(/^use\s+([A-Za-z][A-Za-z0-9]*(?:\.[A-Za-z][A-Za-z0-9]*)*)(?:\s+from\s+"([^"]+)")?$/))
 		.filter((match): match is RegExpMatchArray => Boolean(match))
-		.map((match) => ({ moduleName: match[1]!, from: match[2] ?? stdPathFor(match[1]!), input }));
+		.map((match) => ({ moduleName: match[1]!, from: match[2] ?? modulePathFromLock(lock, match[1]!), input }));
 }
 
-function createModuleGraph(results: CoreFile[]): ModuleGraph {
+function createModuleGraph(results: CoreFile[], lock: Awaited<ReturnType<typeof readPointLock>>): ModuleGraph {
 	const byInput = new Map(results.map((result) => [normalizeInput(result.input), result]));
 	const graph: ModuleGraph = new Map();
 	for (const result of results) {
@@ -495,11 +529,6 @@ function resolveDependencyInput(input: string, from: string): string {
 	return resolve(base, from).replace(resolve(process.cwd()), "").replace(/^[/\\]/, "");
 }
 
-function stdPathFor(moduleName: string): string {
-	if (!moduleName.startsWith("std.")) throw new Error(`Use declarations without from must target std modules: ${moduleName}`);
-	return `${moduleName.replace(/^std\./, "std/").replaceAll(".", "/")}.point`;
-}
-
 function normalizeInput(input: string): string {
 	return input.replaceAll("\\", "/");
 }

package/src/core/context.ts

@@ -27,6 +27,7 @@ export type PointCoreSymbolKind =
 	| "action"
 	| "policy"
 	| "view"
+	| "page"
 	| "route"
 	| "workflow"
 	| "command";
@@ -325,6 +326,7 @@ function relatedRefsFor(symbol: PointCoreSymbol, index: PointCoreIndex): string[
 		symbol.kind === "action" ||
 		symbol.kind === "policy" ||
 		symbol.kind === "view" ||
+		symbol.kind === "page" ||
 		symbol.kind === "route" ||
 		symbol.kind === "workflow" ||
 		symbol.kind === "command"
@@ -351,6 +353,7 @@ function summaryFor(symbol: PointCoreSymbol): string {
 	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 === "page") return `Semantic page ${symbol.name} returns a Next.js page shell as 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}.`;

package/src/core/emit-javascript.ts

@@ -52,9 +52,13 @@ function emitDeclaration(declaration: PointCoreDeclaration): string[] {
 
 function emitFunction(declaration: PointCoreFunctionDeclaration): string[] {
 	const asyncPrefix = declaration.semantic?.kind === "action" || declaration.semantic?.kind === "workflow" || declaration.semantic?.kind === "command" ? "async " : "";
+	const bodyLines =
+		declaration.semantic?.kind === "page" && declaration.semantic.pageLayout
+			? [`return ${emitExpression(declaration.semantic.pageLayout.main)};`]
+			: declaration.body.flatMap((statement) => emitStatement(statement, declaration.semantic?.kind));
 	return [
 		`export ${asyncPrefix}function ${declaration.name}(${declaration.params.map(emitParam).join(", ")}) {`,
-		...indentLines(declaration.body.flatMap((statement) => emitStatement(statement, declaration.semantic?.kind))),
+		...indentLines(bodyLines),
 		"}",
 	];
 }

package/src/core/emit-python.ts

@@ -1,6 +1,7 @@
 import type {
 	PointCoreDeclaration,
 	PointCoreExpression,
+	PointCoreExternalDeclaration,
 	PointCoreFunctionDeclaration,
 	PointCoreParameter,
 	PointCorePrimitiveType,
@@ -16,7 +17,12 @@ const BINARY_OPERATORS: Record<string, string> = {
 	or: "or",
 };
 
-const UNSUPPORTED_SEMANTIC_KINDS = new Set(["view", "route", "action", "workflow", "command"]);
+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 {
@@ -42,11 +48,7 @@ function emitDeclaration(declaration: PointCoreDeclaration): string[] {
 		const moduleName = declaration.from.replace(/^\.\//, "").replace(/-/g, "_");
 		return [`from ${toPythonModuleName(moduleName)} import ${declaration.names.join(", ")}`];
 	}
-	if (declaration.kind === "external") {
-		const moduleName = declaration.from.replace(/^\.\//, "").replace(/-/g, "_");
-		const imported = declaration.importName ?? declaration.name;
-		return [`from ${toPythonModuleName(moduleName)} import ${imported} as ${declaration.name}`];
-	}
+	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)) {
@@ -62,6 +64,19 @@ function emitType(declaration: PointCoreTypeDeclaration): string[] {
 	];
 }
 
+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 [
@@ -79,7 +94,7 @@ function emitReturnType(declaration: PointCoreFunctionDeclaration): string {
 
 function emitStatement(statement: PointCoreStatement, semanticKind?: string): string[] {
 	if (statement.kind === "return") {
-		if (semanticKind === "view") return ["# Point: view return values are not supported in Python emit yet", "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)];

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,18 +57,86 @@ 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) {
@@ -114,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

@@ -7,6 +7,7 @@ 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"

package/src/semantic/ast.ts

@@ -24,6 +24,7 @@ export type PointSemanticDeclaration =
 	| PointSemanticActionDeclaration
 	| PointSemanticPolicyDeclaration
 	| PointSemanticViewDeclaration
+	| PointSemanticPageDeclaration
 	| PointSemanticRouteDeclaration
 	| PointSemanticWorkflowDeclaration
 	| PointSemanticCommandDeclaration;
@@ -123,6 +124,16 @@ export interface PointSemanticViewDeclaration {
 	span?: PointSourceSpan;
 }
 
+export interface PointSemanticPageDeclaration {
+	kind: "page";
+	name: string;
+	inputs: PointSemanticBinding[];
+	title: PointSemanticExpression;
+	description?: PointSemanticExpression;
+	main: PointSemanticExpression;
+	span?: PointSourceSpan;
+}
+
 export interface PointSemanticRouteDeclaration {
 	kind: "route";
 	name: string;
@@ -182,7 +193,9 @@ export type PointSemanticPolicyStatement =
 
 export type PointSemanticViewStatement =
 	| { kind: "render"; value: PointSemanticExpression; span?: PointSourceSpan }
-	| { kind: "whenRender"; condition: PointSemanticExpression; value: PointSemanticExpression; span?: PointSourceSpan };
+	| { kind: "whenRender"; condition: PointSemanticExpression; value: PointSemanticExpression; span?: PointSourceSpan }
+	| { kind: "bindCheckbox"; label: string; target: PointSemanticExpression; span?: PointSourceSpan }
+	| { kind: "onChangeCall"; callback: string; span?: PointSourceSpan };
 
 export type PointSemanticRouteStatement = { kind: "return"; value: PointSemanticExpression; span?: PointSourceSpan };
 

package/src/semantic/callables.ts

@@ -4,6 +4,7 @@ const CALLABLE_KEYWORDS = [
 	"label",
 	"action",
 	"view",
+	"page",
 	"route",
 	"workflow",
 	"command",
@@ -47,5 +48,5 @@ function collectBody(lines: string[], start: number): { lines: string[]; next: n
 }
 
 function isTopLevel(line: string): boolean {
-	return /^(module|use|record|calculation|rule|label|external|action|policy|view|route|workflow|command)\s+/.test(line);
+	return /^(module|use|record|calculation|rule|label|external|action|policy|view|page|route|workflow|command)\s+/.test(line);
 }

package/src/semantic/context.ts

@@ -27,6 +27,7 @@ export type PointSemanticSymbolKind =
 	| "action"
 	| "policy"
 	| "view"
+	| "page"
 	| "route"
 	| "workflow"
 	| "command"
@@ -215,6 +216,15 @@ function callableDeclaration(declaration: PointSemanticDeclaration):
 	if (declaration.kind === "view" || declaration.kind === "route" || declaration.kind === "workflow" || declaration.kind === "command") {
 		return { kind: declaration.kind, name: declaration.name, inputs: declaration.inputs, output: declaration.output, declaration };
 	}
+	if (declaration.kind === "page") {
+		return {
+			kind: "page",
+			name: declaration.name,
+			inputs: declaration.inputs,
+			output: { name: "page", type: { kind: "typeRef", name: "Page", args: [] } },
+			declaration,
+		};
+	}
 	return null;
 }
 
@@ -313,7 +323,7 @@ function relatedRefsFor(symbol: PointSemanticSymbol, index: PointSemanticIndex):
 		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 === "record" || 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" || symbol.kind === "external") {
+	if (symbol.kind === "record" || symbol.kind === "calculation" || symbol.kind === "rule" || symbol.kind === "label" || symbol.kind === "action" || symbol.kind === "policy" || symbol.kind === "view" || symbol.kind === "page" || symbol.kind === "route" || symbol.kind === "workflow" || symbol.kind === "command" || symbol.kind === "external") {
 		return index.refs.filter((candidate) => candidate.path.startsWith(`${symbol.path}.`)).map((candidate) => candidate.ref);
 	}
 	return [];
@@ -332,6 +342,7 @@ function summaryFor(symbol: PointSemanticSymbol): string {
 	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 ${symbol.type}.`;
+	if (symbol.kind === "page") return `Semantic page ${symbol.name} returns a Next.js page shell (${symbol.type}).`;
 	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}.`;

package/src/semantic/desugar.ts

@@ -11,6 +11,7 @@ import type {
 	PointCoreTypeExpression,
 	PointCoreValueDeclaration,
 	PointSourceSpan,
+	PointSemanticViewControls,
 } from "../core/ast.ts";
 import type {
 	PointSemanticBinding,
@@ -35,6 +36,8 @@ import type {
 	PointSemanticTypeExpression,
 	PointSemanticUseDeclaration,
 	PointSemanticViewDeclaration,
+	PointSemanticViewStatement,
+	PointSemanticPageDeclaration,
 	PointSemanticWorkflowDeclaration,
 	PointSemanticWorkflowStatement,
 	PointSemanticActionDeclaration,
@@ -104,6 +107,7 @@ function buildCallableMap(
 			declaration.kind === "action" ||
 			declaration.kind === "policy" ||
 			declaration.kind === "view" ||
+			declaration.kind === "page" ||
 			declaration.kind === "route" ||
 			declaration.kind === "workflow" ||
 			declaration.kind === "command"
@@ -119,6 +123,7 @@ function defaultOutputName(declaration: PointSemanticDeclaration): string {
 	if (declaration.kind === "label") return "label";
 	if (declaration.kind === "policy") return "policy";
 	if (declaration.kind === "view") return "view";
+	if (declaration.kind === "page") return "page";
 	if (declaration.kind === "route") return "route";
 	if ("output" in declaration) return toIdentifier(declaration.output.name);
 	return "result";
@@ -152,6 +157,8 @@ function desugarDeclaration(
 			return [desugarPolicy(declaration, records, callables)];
 		case "view":
 			return [desugarView(declaration, records, callables)];
+		case "page":
+			return [desugarPage(declaration, records, callables)];
 		case "route":
 			return [desugarRoute(declaration, records, callables)];
 		case "workflow":
@@ -296,13 +303,85 @@ function desugarView(
 	const outputType: PointCoreTypeExpression = { kind: "typeRef", name: "Text", args: [] };
 	const { params, bindings } = collectBindings(declaration.inputs, declaration.output);
 	const ctx: DesugarContext = { records, callables, bindings, outputName: "page", outputType };
+	const renderStatements = declaration.body.filter(
+		(statement): statement is Extract<PointSemanticViewStatement, { kind: "render" | "whenRender" }> =>
+			statement.kind === "render" || statement.kind === "whenRender",
+	);
+	const metadata = semanticDeclarationMetadata(declaration);
+	const viewControls = buildViewControls(declaration, ctx);
+	if (viewControls) metadata.viewControls = viewControls;
 	return {
 		kind: "function",
 		name: semanticFunctionName(declaration.name, "view", "view"),
 		params,
 		returnType: outputType,
-		body: desugarViewBody(declaration.body, ctx),
-		semantic: semanticDeclarationMetadata(declaration),
+		body: desugarViewBody(renderStatements, ctx),
+		semantic: metadata,
+		span: declaration.span,
+	};
+}
+
+function buildViewControls(
+	declaration: PointSemanticViewDeclaration,
+	ctx: DesugarContext,
+): PointSemanticViewControls | undefined {
+	const bindStatements = declaration.body.filter(
+		(statement): statement is Extract<PointSemanticViewStatement, { kind: "bindCheckbox" }> => statement.kind === "bindCheckbox",
+	);
+	if (bindStatements.length === 0) return undefined;
+
+	const onChangeCall = declaration.body.find(
+		(statement): statement is Extract<PointSemanticViewStatement, { kind: "onChangeCall" }> => statement.kind === "onChangeCall",
+	);
+	const handlerInput = declaration.inputs.find((input) => input.type.name === "Handler" && input.type.args.length === 1);
+	const callbackLabel = onChangeCall?.callback ?? handlerInput?.label;
+	if (!callbackLabel) {
+		throw new Error(`View ${declaration.name} with bind checkbox requires input Handler T or on change call`);
+	}
+	const changeCallback = toIdentifier(callbackLabel);
+
+	return {
+		changeCallback,
+		checkboxes: bindStatements.map((statement) => {
+			const target = desugarExpression(statement.target, ctx);
+			if (target.kind !== "property") {
+				throw new Error(`bind checkbox target must be a record field access`);
+			}
+			if (target.target.kind !== "identifier") {
+				throw new Error(`bind checkbox target must start with an input record`);
+			}
+			return {
+				label: statement.label,
+				target,
+				recordParam: target.target.name,
+				fieldName: target.name,
+			};
+		}),
+	};
+}
+
+function desugarPage(
+	declaration: PointSemanticPageDeclaration,
+	records: Map<string, Map<string, string>>,
+	callables: Map<string, string>,
+): PointCoreFunctionDeclaration {
+	const outputType: PointCoreTypeExpression = { kind: "typeRef", name: "Text", args: [] };
+	const pageType: PointCoreTypeExpression = { kind: "typeRef", name: "Page", args: [] };
+	const { params, bindings } = collectBindings(declaration.inputs, { name: "page", type: pageType });
+	const ctx: DesugarContext = { records, callables, bindings, outputName: "page", outputType };
+	const metadata = semanticDeclarationMetadata(declaration);
+	metadata.pageLayout = {
+		title: desugarExpression(declaration.title, ctx),
+		description: declaration.description ? desugarExpression(declaration.description, ctx) : undefined,
+		main: desugarExpression(declaration.main, ctx),
+	};
+	return {
+		kind: "function",
+		name: semanticFunctionName(declaration.name, "page", "page"),
+		params,
+		returnType: outputType,
+		body: [{ kind: "return", value: metadata.pageLayout.main, span: declaration.span }],
+		semantic: metadata,
 		span: declaration.span,
 	};
 }
@@ -390,7 +469,7 @@ function desugarParameter(binding: PointSemanticBinding): PointCoreParameter {
 }
 
 function desugarType(type: PointSemanticTypeExpression): PointCoreTypeExpression {
-	if (type.name === "List" || type.name === "Maybe" || type.name === "Or") {
+	if (type.name === "List" || type.name === "Maybe" || type.name === "Or" || type.name === "Handler") {
 		return { kind: "typeRef", name: type.name, args: type.args.map(desugarType) };
 	}
 	const primitives = new Set(["Text", "Int", "Float", "Bool", "Void", "Error", "Page"]);

package/src/semantic/expressions.ts

@@ -32,6 +32,14 @@ export function parseSemanticTypeExpression(source: string): PointSemanticTypeEx
 	if (maybeMatch) {
 		return { kind: "typeRef", name: "Maybe", args: [parseSemanticTypeExpression(maybeMatch[1] ?? "")] };
 	}
+	const handlerMatch = trimmed.match(/^Handler\s+(.+)$/);
+	if (handlerMatch) {
+		return { kind: "typeRef", name: "Handler", args: [parseSemanticTypeExpression(handlerMatch[1] ?? "")] };
+	}
+	const handlerGenericMatch = trimmed.match(/^Handler<(.+)>$/);
+	if (handlerGenericMatch) {
+		return { kind: "typeRef", name: "Handler", args: [parseSemanticTypeExpression(handlerGenericMatch[1] ?? "")] };
+	}
 	return { kind: "typeRef", name: trimmed, args: [] };
 }
 

package/src/semantic/format.ts

@@ -83,6 +83,14 @@ function formatDeclaration(declaration: PointSemanticDeclaration): string[] {
 				...formatViewOutput(declaration.output),
 				...declaration.body.map((statement) => `  ${formatViewStatement(statement)}`),
 			];
+		case "page":
+			return [
+				`page ${declaration.name}`,
+				...formatInputs(declaration.inputs),
+				`  title ${formatExpression(declaration.title)}`,
+				...(declaration.description ? [`  description ${formatExpression(declaration.description)}`] : []),
+				`  main render ${formatExpression(declaration.main)}`,
+			];
 		case "route":
 			return [
 				`route ${declaration.name}`,
@@ -176,6 +184,8 @@ function formatPolicyStatement(statement: PointSemanticPolicyStatement): string
 
 function formatViewStatement(statement: PointSemanticViewStatement): string {
 	if (statement.kind === "whenRender") return `when ${formatExpression(statement.condition)} render ${formatExpression(statement.value)}`;
+	if (statement.kind === "bindCheckbox") return `bind checkbox "${statement.label}" to ${formatExpression(statement.target)}`;
+	if (statement.kind === "onChangeCall") return `on change call ${statement.callback}`;
 	return `render ${formatExpression(statement.value)}`;
 }
 

package/src/semantic/metadata.ts

@@ -30,6 +30,9 @@ export function semanticDeclarationMetadata(declaration: PointSemanticDeclaratio
 			effects: [],
 		};
 	}
+	if (declaration.kind === "page") {
+		return { kind: "page", name: declaration.name, outputName: "page", effects: [] };
+	}
 	if (declaration.kind === "route") {
 		return { kind: "route", name: declaration.name, outputName: declaration.output.name, effects: [] };
 	}

package/src/semantic/naming.ts

@@ -11,7 +11,7 @@ export function toIdentifier(label: string): string {
 export 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 =
@@ -21,7 +21,9 @@ export function semanticFunctionName(
 				? "Policy"
 				: kind === "view"
 					? "View"
-					: kind === "route"
+					: kind === "page"
+						? "Page"
+						: kind === "route"
 						? "Route"
 						: kind === "workflow"
 							? "Workflow"

package/src/semantic/parse.ts

@@ -25,6 +25,7 @@ import type {
 	PointSemanticUseDeclaration,
 	PointSemanticViewDeclaration,
 	PointSemanticViewStatement,
+	PointSemanticPageDeclaration,
 	PointSemanticWorkflowDeclaration,
 	PointSemanticWorkflowStatement,
 	PointSemanticBinding,
@@ -129,6 +130,12 @@ export function parseSemanticSource(source: string): PointSemanticProgram {
 			index = parsed.next;
 			continue;
 		}
+		if (trimmed.startsWith("page ")) {
+			const parsed = parsePage(lines, index, source, records, callables);
+			declarations.push(parsed.declaration);
+			index = parsed.next;
+			continue;
+		}
 		if (trimmed.startsWith("route ")) {
 			const parsed = parseRoute(lines, index, source, records, callables);
 			declarations.push(parsed.declaration);
@@ -586,6 +593,24 @@ function parseView(
 			});
 			continue;
 		}
+		const bindCheckbox = line.match(/^bind checkbox "(.+)" to (.+)$/);
+		if (bindCheckbox) {
+			statements.push({
+				kind: "bindCheckbox",
+				label: bindCheckbox[1] ?? "",
+				target: parseLineExpression(bindCheckbox[2] ?? "", context, source, lineNumber),
+				span: lineSpan(source, lineNumber),
+			});
+			continue;
+		}
+		if (line.startsWith("on change call ")) {
+			statements.push({
+				kind: "onChangeCall",
+				callback: line.slice("on change call ".length).trim(),
+				span: lineSpan(source, lineNumber),
+			});
+			continue;
+		}
 		throw new Error(`Unknown view statement: ${line}`);
 	}
 
@@ -595,6 +620,57 @@ function parseView(
 	};
 }
 
+function parsePage(
+	lines: string[],
+	start: number,
+	source: string,
+	records: Map<string, Map<string, string>>,
+	callables: string[],
+): { declaration: PointSemanticPageDeclaration; next: number } {
+	const name = (lines[start] ?? "").trim().slice("page ".length).trim();
+	const body = collectSemanticBody(lines, start + 1);
+	const inputs: PointSemanticBinding[] = [];
+	const paramTypes = new Map<string, string>();
+	const bindings: string[] = [];
+	let title: PointSemanticPageDeclaration["title"] | undefined;
+	let description: PointSemanticPageDeclaration["description"];
+	let main: PointSemanticPageDeclaration["main"] | undefined;
+
+	for (let lineIndex = 0; lineIndex < body.lines.length; lineIndex += 1) {
+		const line = body.lines[lineIndex] ?? "";
+		const lineNumber = body.lineNumbers[lineIndex] ?? start + 2;
+		if (line.startsWith("input ")) {
+			const binding = parseInputBinding(line.slice("input ".length), source, lineNumber);
+			inputs.push(binding);
+			paramTypes.set(binding.label, typeLabel(binding.type));
+			bindings.push(binding.label);
+			continue;
+		}
+		const context = buildExpressionContext({ bindings, paramTypes, recordFields: records, callables });
+		if (line.startsWith("title ")) {
+			title = parseLineExpression(line.slice("title ".length), context, source, lineNumber);
+			continue;
+		}
+		if (line.startsWith("description ")) {
+			description = parseLineExpression(line.slice("description ".length), context, source, lineNumber);
+			continue;
+		}
+		if (line.startsWith("main render ")) {
+			main = parseLineExpression(line.slice("main render ".length), context, source, lineNumber);
+			continue;
+		}
+		throw new Error(`Unknown page statement: ${line}`);
+	}
+
+	if (!title) throw new Error(`Page ${name} requires a title`);
+	if (!main) throw new Error(`Page ${name} requires main render`);
+
+	return {
+		declaration: { kind: "page", name, inputs, title, description, main, span: lineSpan(source, start + 1) },
+		next: body.next,
+	};
+}
+
 function parseRoute(
 	lines: string[],
 	start: number,
@@ -893,7 +969,7 @@ function collectSemanticBody(lines: string[], start: number): SemanticBody {
 }
 
 function isSemanticTopLevel(line: string): boolean {
-	return /^(module|use|record|calculation|rule|label|external|action|policy|view|route|workflow|command)\s+/.test(line);
+	return /^(module|use|record|calculation|rule|label|external|action|policy|view|page|route|workflow|command)\s+/.test(line);
 }
 
 function isLoopBoundary(line: string): boolean {
@@ -914,7 +990,10 @@ function typeLabel(type: { kind: "typeRef"; name: string; args: unknown[] }): st
 	if (type.name === "Maybe" && type.args[0]) {
 		return `Maybe<${typeLabel(type.args[0] as { kind: "typeRef"; name: string; args: unknown[] })}>`;
 	}
-	const primitives = new Set(["Text", "Int", "Float", "Bool", "Void", "Maybe", "Or", "Error", "Page"]);
+	if (type.name === "Handler" && type.args[0]) {
+		return `Handler ${typeLabel(type.args[0] as { kind: "typeRef"; name: string; args: unknown[] })}`;
+	}
+	const primitives = new Set(["Text", "Int", "Float", "Bool", "Void", "Maybe", "Or", "Error", "Page", "Handler"]);
 	if (primitives.has(type.name)) return type.name;
 	return toPascalCase(type.name);
 }

package/src/std/http.ts

@@ -0,0 +1,30 @@
+type PointStdError = { message: string };
+
+async function readResponseText(response: Response): Promise<string | PointStdError> {
+	if (!response.ok) {
+		return { message: `HTTP ${response.status}: ${response.statusText}` };
+	}
+	return response.text();
+}
+
+export async function httpGet(url: string): Promise<string | PointStdError> {
+	try {
+		return await readResponseText(await fetch(url));
+	} catch (error) {
+		return { message: error instanceof Error ? error.message : String(error) };
+	}
+}
+
+export async function httpPost(url: string, body: string): Promise<string | PointStdError> {
+	try {
+		return await readResponseText(
+			await fetch(url, {
+				method: "POST",
+				headers: { "Content-Type": "text/plain; charset=utf-8" },
+				body,
+			}),
+		);
+	} catch (error) {
+		return { message: error instanceof Error ? error.message : String(error) };
+	}
+}

package/src/std/json.ts

@@ -0,0 +1,13 @@
+export type PointStdError = { message: string };
+
+export function jsonParse(value: string): string | PointStdError {
+	try {
+		return JSON.stringify(JSON.parse(value));
+	} catch (error) {
+		return { message: error instanceof Error ? error.message : String(error) };
+	}
+}
+
+export function jsonStringify(value: string): string {
+	return JSON.stringify(JSON.parse(value));
+}