@hatchingpoint/point 0.0.11 → 0.0.13

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: [] };
 }
 
@@ -138,9 +146,8 @@ function parsePrimaryExpression(source: string, context: PointSemanticExpression
 		return parseRecordExpression(trimmed, context);
 	}
 	if (trimmed.startsWith('"')) {
-		const end = trimmed.indexOf('"', 1);
-		const value = JSON.parse(trimmed.slice(0, end + 1));
-		return { expression: { kind: "literal", value }, consumed: trimmed.slice(end + 1) };
+		const literal = parseJsonStringLiteral(trimmed);
+		return { expression: { kind: "literal", value: literal.value }, consumed: literal.consumed };
 	}
 	if (/^(true|false|null|none)\b/.test(trimmed)) {
 		const match = trimmed.match(/^(true|false|null|none)\b/);
@@ -183,6 +190,24 @@ function parsePrimaryExpression(source: string, context: PointSemanticExpression
 	throw new Error(`Unable to parse semantic expression: ${source}`);
 }
 
+function parseJsonStringLiteral(source: string): { value: string; consumed: string } {
+	if (!source.startsWith('"')) throw new Error(`Expected string literal: ${source}`);
+	let index = 1;
+	while (index < source.length) {
+		const char = source[index];
+		if (char === "\\") {
+			index += 2;
+			continue;
+		}
+		if (char === '"') {
+			const value = JSON.parse(source.slice(0, index + 1)) as string;
+			return { value, consumed: source.slice(index + 1) };
+		}
+		index += 1;
+	}
+	throw new Error(`Unterminated string literal: ${source}`);
+}
+
 function parseListExpression(source: string, context: PointSemanticExpressionContext): { expression: PointSemanticExpression; consumed: string } {
 	let rest = source.trim().slice(1).trimStart();
 	const items: PointSemanticExpression[] = [];

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));
+}