@hatchingpoint/point 0.0.12 → 0.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchingpoint/point",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "private": false,
   "type": "module",
   "description": "Point language compiler and CLI.",
@@ -24,7 +24,13 @@
   "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",
+    "./std/text": "./src/std/text.ts",
+    "./std/time": "./src/std/time.ts",
+    "./std/fs": "./src/std/fs.ts",
+    "./std/env": "./src/std/env.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,13 @@ 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 { canBundleRunInMemory, executeBundledEntry } from "./run-bridge.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";
@@ -22,7 +24,17 @@ const DEFAULT_PATTERNS = ["examples/**/*.point", "std/**/*.point", "compiler/**/
 const GENERATED_DIR = "generated";
 
 export async function main() {
-	const [, , command = "check", input = DEFAULT_INPUT, output = DEFAULT_OUTPUT] = Bun.argv;
+	const command = Bun.argv[2] ?? "check";
+	const tail = Bun.argv.slice(3);
+	let input = tail[0] ?? DEFAULT_INPUT;
+	let output = tail[1] ?? DEFAULT_OUTPUT;
+	let runFlags: Record<string, boolean | undefined> | undefined;
+	if (command === "run") {
+		const parsed = parseCliFlags(tail);
+		runFlags = parsed.flags;
+		input = parsed.positional[0] ?? DEFAULT_INPUT;
+		output = parsed.positional[1] ?? DEFAULT_OUTPUT;
+	}
 	if (command.endsWith("-all")) {
 		await runProjectCommand(command);
 		return;
@@ -43,6 +55,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);
@@ -163,16 +187,17 @@ export async function main() {
 			console.error(JSON.stringify({ ok: false, diagnostics }, null, 2));
 			process.exit(1);
 		}
-		const runOutput = resolve(tmpdir(), `point-run-${Date.now()}.js`);
-		await Bun.write(runOutput, emitPointCoreJavaScript(program));
 		let entryName: string | null = null;
 		try {
-			const mod = await import(pathToFileUrl(runOutput));
 			entryName = findRunEntryName(program);
 			if (!entryName) throw new Error("No zero-argument entrypoint found. Define an action or calculation with no inputs.");
-			const entry = mod[entryName];
-			if (typeof entry !== "function") throw new Error(`Entrypoint ${entryName} was not exported.`);
-			const value = await entry();
+			const useBundle = runFlags?.bundle === true || (runFlags?.bundle !== false && canBundleRunInMemory(program));
+			if (runFlags?.bundle === true && !canBundleRunInMemory(program)) {
+				throw new Error("Cannot use --bundle: module has imports, externals, or non-pure logic (views, routes, workflows, commands).");
+			}
+			const value = useBundle
+				? await executeBundledEntry(program, entryName)
+				: await executeTempModuleRun(program, entryName);
 			if (value !== undefined) console.log(typeof value === "string" ? value : JSON.stringify(value));
 		} catch (error) {
 			console.error(`Runtime error in ${runtimeSourceLocation(program, input, entryName)}: ${error instanceof Error ? error.message : String(error)}`);
@@ -198,8 +223,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 +324,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 })),
@@ -400,6 +446,26 @@ function pathToFileUrl(path: string): string {
 	return `file://${path.replaceAll("\\", "/")}`;
 }
 
+async function executeTempModuleRun(program: PointCoreProgram, entryName: string): Promise<unknown> {
+	const runOutput = resolve(tmpdir(), `point-run-${Date.now()}.js`);
+	await Bun.write(runOutput, emitPointCoreJavaScript(program));
+	const mod = await import(pathToFileUrl(runOutput));
+	const entry = mod[entryName];
+	if (typeof entry !== "function") throw new Error(`Entrypoint ${entryName} was not exported.`);
+	return await entry();
+}
+
+function parseCliFlags(args: string[]): { flags: Record<string, boolean | undefined>; positional: string[] } {
+	const flags: Record<string, boolean | undefined> = {};
+	const positional: string[] = [];
+	for (const arg of args) {
+		if (arg === "--bundle") flags.bundle = true;
+		else if (arg === "--no-bundle") flags.bundle = false;
+		else positional.push(arg);
+	}
+	return { flags, positional };
+}
+
 export function findRunEntryName(program: PointCoreProgram): string | null {
 	const zeroArgFunctions = program.declarations.filter((declaration) => declaration.kind === "function" && declaration.params.length === 0);
 	const preferred =
@@ -409,9 +475,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 +489,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) {
@@ -490,14 +556,12 @@ function publicDeclarations(program: PointCoreProgram): Array<Extract<PointCoreD
 }
 
 function resolveDependencyInput(input: string, from: string): string {
-	if (from.startsWith("std/")) return from;
-	const base = dirname(resolve(process.cwd(), input));
-	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`;
+	const normalized = from.replaceAll("\\", "/");
+	if (normalized.startsWith("./") || normalized.startsWith("../")) {
+		const base = dirname(resolve(process.cwd(), input));
+		return resolve(base, from).replace(resolve(process.cwd()), "").replace(/^[/\\]/, "");
+	}
+	return normalized;
 }
 
 function normalizeInput(input: string): string {

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";