@hatchingpoint/point 0.0.10 → 0.0.12

package/README.md

@@ -13,7 +13,7 @@ point check examples/math.point
 
 Pair with the [Point Language](https://marketplace.visualstudio.com/items?itemName=hatchingpoint.point) extension in VS Code or Cursor.
 
-Point's public source language is semantic product logic. The compiler lowers that source into an internal typed core and emits TypeScript for existing JavaScript infrastructure.
+Point's public source language is semantic product logic. The compiler lowers that source into an internal typed core and emits JavaScript by default for Bun and Node. Use `point build-ts` when you need TypeScript for existing typed JavaScript infrastructure.
 
 This package is the source of truth for Point. It exposes:
 
@@ -29,6 +29,6 @@ bun run check
 bun run build
 ```
 
-`bun run build` emits TypeScript into `generated/` for React, Vue, Bun, Node, and Vite projects.
+`bun run build` emits JavaScript into `generated/` by default. Use `bun run build:ts` for TypeScript and `bun run build:ast` when debugging compiler output.
 
 When Point is extracted, this package can move into a standalone repo with the same package name and public entrypoints.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchingpoint/point",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "private": false,
   "type": "module",
   "description": "Point language compiler and CLI.",

package/src/core/check-docs.ts

@@ -0,0 +1,155 @@
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import type { PointCoreDiagnostic } from "./check.ts";
+import { checkPointCore } from "./check.ts";
+import { parsePointSource } from "./parser.ts";
+
+const DEFAULT_DOCS_DIR = "docs/site";
+const POINT_FENCE = /```point\r?\n([\s\S]*?)```/g;
+const POINT_FILE_REF = /\b(?:[\w.-]+\/)*[\w.-]+\.point\b/g;
+
+export interface DocsCheckItemResult {
+	kind: "snippet" | "file";
+	source: string;
+	label: string;
+	line?: number;
+	ok: boolean;
+	diagnostics: PointCoreDiagnostic[];
+}
+
+export interface DocsCheckResult {
+	ok: boolean;
+	checked: number;
+	items: DocsCheckItemResult[];
+}
+
+export async function discoverDocsSiteMarkdown(docsDir = DEFAULT_DOCS_DIR, cwd = process.cwd()): Promise<string[]> {
+	const root = resolve(cwd, docsDir);
+	const glob = new Bun.Glob("**/*.md");
+	const files: string[] = [];
+	for await (const file of glob.scan({ cwd: root, onlyFiles: true })) {
+		files.push(`${docsDir}/${file.replaceAll("\\", "/")}`);
+	}
+	return files.sort((a, b) => a.localeCompare(b));
+}
+
+export function extractPointSnippets(markdown: string, source: string): Array<{ label: string; code: string; line: number }> {
+	const snippets: Array<{ label: string; code: string; line: number }> = [];
+	let index = 0;
+	for (const match of markdown.matchAll(POINT_FENCE)) {
+		index += 1;
+		const code = match[1]?.replace(/\s+$/, "") ?? "";
+		const line = markdown.slice(0, match.index ?? 0).split(/\r?\n/).length;
+		snippets.push({ label: `${source} snippet ${index}`, code, line });
+	}
+	return snippets;
+}
+
+export function extractPointFileReferences(markdown: string, markdownPath: string, cwd = process.cwd()): string[] {
+	const references = new Set<string>();
+	for (const match of markdown.matchAll(POINT_FILE_REF)) {
+		const candidate = match[0]!;
+		if (candidate.endsWith(".point")) references.add(candidate.replaceAll("\\", "/"));
+	}
+	const resolved: string[] = [];
+	for (const reference of references) {
+		const absolute = resolvePointFileReference(reference, markdownPath, cwd);
+		if (absolute) resolved.push(absolute);
+	}
+	return resolved.sort((a, b) => a.localeCompare(b));
+}
+
+function resolvePointFileReference(reference: string, markdownPath: string, cwd: string): string | null {
+	const candidates = [
+		resolve(cwd, reference),
+		resolve(cwd, dirname(markdownPath), reference),
+	];
+	for (const candidate of candidates) {
+		if (!existsSync(candidate)) continue;
+		return candidate.replace(resolve(cwd), "").replace(/^[/\\]/, "").replaceAll("\\", "/");
+	}
+	return null;
+}
+
+function checkPointSource(source: string, label: string, kind: "snippet" | "file", markdownSource: string, line?: number): DocsCheckItemResult {
+	try {
+		const program = parsePointSource(source);
+		const diagnostics = checkPointCore(program);
+		return { kind, source: markdownSource, label, line, ok: diagnostics.length === 0, diagnostics };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return {
+			kind,
+			source: markdownSource,
+			label,
+			line,
+			ok: false,
+			diagnostics: [
+				{
+					code: "parse-error",
+					message,
+					path: label,
+					ref: `point://docs/${label}`,
+					severity: "error",
+					span: null,
+					repair: "Fix the Point syntax in this docs snippet or referenced file.",
+				},
+			],
+		};
+	}
+}
+
+export async function checkDocs(options: { docsDir?: string; cwd?: string } = {}): Promise<DocsCheckResult> {
+	const docsDir = options.docsDir ?? DEFAULT_DOCS_DIR;
+	const cwd = options.cwd ?? process.cwd();
+	const markdownFiles = await discoverDocsSiteMarkdown(docsDir, cwd);
+	const items: DocsCheckItemResult[] = [];
+	const checkedFiles = new Set<string>();
+
+	for (const markdownPath of markdownFiles) {
+		const absoluteMarkdownPath = resolve(cwd, markdownPath);
+		const markdown = await Bun.file(absoluteMarkdownPath).text();
+
+		for (const snippet of extractPointSnippets(markdown, markdownPath)) {
+			items.push(checkPointSource(snippet.code, snippet.label, "snippet", markdownPath, snippet.line));
+		}
+
+		for (const filePath of extractPointFileReferences(markdown, markdownPath, cwd)) {
+			if (checkedFiles.has(filePath)) continue;
+			checkedFiles.add(filePath);
+			const source = await Bun.file(resolve(cwd, filePath)).text();
+			items.push(checkPointSource(source, filePath, "file", markdownPath));
+		}
+	}
+
+	return { ok: items.every((item) => item.ok), checked: items.length, items };
+}
+
+export async function runCheckDocs(options: { docsDir?: string; cwd?: string } = {}): Promise<DocsCheckResult> {
+	const result = await checkDocs(options);
+	if (result.ok) {
+		const snippets = result.items.filter((item) => item.kind === "snippet").length;
+		const files = result.items.filter((item) => item.kind === "file").length;
+		console.log(`Point docs check passed: ${snippets} snippet(s), ${files} file reference(s)`);
+		return result;
+	}
+
+	const failures = result.items.filter((item) => !item.ok);
+	console.error(
+		JSON.stringify(
+			{
+				ok: false,
+				failures: failures.map((item) => ({
+					kind: item.kind,
+					source: item.source,
+					label: item.label,
+					line: item.line,
+					diagnostics: item.diagnostics,
+				})),
+			},
+			null,
+			2,
+		),
+	);
+	process.exit(1);
+}

package/src/core/cli.ts

@@ -6,14 +6,18 @@ 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 { 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 { runPointLspServer } from "../lsp/server.ts";
 
 const DEFAULT_INPUT = "examples/math.point";
 const DEFAULT_OUTPUT = "generated/math.ast.json";
+const DEFAULT_JS_OUTPUT = "generated/math.js";
 const DEFAULT_TS_OUTPUT = "generated/math.ts";
+const DEFAULT_PY_OUTPUT = "generated/math.py";
 const DEFAULT_PATTERNS = ["examples/**/*.point", "std/**/*.point", "compiler/**/*.point"];
 const GENERATED_DIR = "generated";
 
@@ -34,6 +38,11 @@ export async function main() {
 		return;
 	}
 
+	if (command === "check-docs") {
+		await runCheckDocs();
+		return;
+	}
+
 	const inputPath = resolve(process.cwd(), input);
 	const source = await Bun.file(inputPath).text();
 	const program = parsePointSource(source);
@@ -101,15 +110,27 @@ export async function main() {
 		return;
 	}
 
-	if (command === "build") {
+	if (command === "build" || command === "build-js") {
+		if (diagnostics.length > 0) {
+			console.error(JSON.stringify({ ok: false, diagnostics }, null, 2));
+			process.exit(1);
+		}
+		const outputPath = resolve(process.cwd(), output === DEFAULT_OUTPUT ? DEFAULT_JS_OUTPUT : output);
+		await Bun.$`mkdir -p ${dirname(outputPath)}`.quiet();
+		await Bun.write(outputPath, emitPointCoreJavaScript(program));
+		console.log(`Point core JavaScript build wrote ${outputPath.replaceAll("\\", "/")}`);
+		return;
+	}
+
+	if (command === "build-ast") {
 		if (diagnostics.length > 0) {
 			console.error(JSON.stringify({ ok: false, diagnostics }, null, 2));
 			process.exit(1);
 		}
-		const outputPath = resolve(process.cwd(), output);
+		const outputPath = resolve(process.cwd(), output === DEFAULT_OUTPUT ? DEFAULT_OUTPUT : output);
 		await Bun.$`mkdir -p ${dirname(outputPath)}`.quiet();
 		await Bun.write(outputPath, `${JSON.stringify(program, null, 2)}\n`);
-		console.log(`Point core build wrote ${output}`);
+		console.log(`Point core AST build wrote ${outputPath.replaceAll("\\", "/")}`);
 		return;
 	}
 
@@ -125,15 +146,15 @@ export async function main() {
 		return;
 	}
 
-	if (command === "build-js") {
+	if (command === "build-py") {
 		if (diagnostics.length > 0) {
 			console.error(JSON.stringify({ ok: false, diagnostics }, null, 2));
 			process.exit(1);
 		}
-		const outputPath = resolve(process.cwd(), output === DEFAULT_OUTPUT ? DEFAULT_TS_OUTPUT.replace(/\.ts$/, ".js") : output);
+		const outputPath = resolve(process.cwd(), output === DEFAULT_OUTPUT ? DEFAULT_PY_OUTPUT : output);
 		await Bun.$`mkdir -p ${dirname(outputPath)}`.quiet();
-		await Bun.write(outputPath, emitPointCoreJavaScript(program));
-		console.log(`Point core JavaScript build wrote ${outputPath.replaceAll("\\", "/")}`);
+		await Bun.write(outputPath, emitPointCorePython(program));
+		console.log(`Point core Python build wrote ${outputPath.replaceAll("\\", "/")}`);
 		return;
 	}
 
@@ -142,8 +163,8 @@ export async function main() {
 			console.error(JSON.stringify({ ok: false, diagnostics }, null, 2));
 			process.exit(1);
 		}
-		const runOutput = resolve(tmpdir(), `point-run-${Date.now()}.ts`);
-		await Bun.write(runOutput, emitPointCoreTypeScript(program));
+		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));
@@ -223,7 +244,7 @@ async function runProjectCommand(command: string) {
 		return;
 	}
 
-	if (command === "build-all") {
+	if (command === "build-all" || command === "build-js-all") {
 		const diagnostics = orderedResults.flatMap((result) =>
 			checkPointCore(programWithDependencyDeclarations(result, graph)).map((diagnostic) => ({ ...diagnostic, file: result.input })),
 		);
@@ -232,16 +253,16 @@ async function runProjectCommand(command: string) {
 			process.exit(1);
 		}
 		for (const result of orderedResults) {
-			const output = outputFor(result.input);
+			const output = jsOutputFor(result.input);
 			const outputPath = resolve(process.cwd(), output);
 			await Bun.$`mkdir -p ${dirname(outputPath)}`.quiet();
-			await Bun.write(outputPath, `${JSON.stringify(result.program, null, 2)}\n`);
+			await Bun.write(outputPath, emitPointCoreJavaScript(programWithTypeScriptImports(result, graph)));
 		}
-		console.log(`Point core build wrote ${results.length} files`);
+		console.log(`Point core JavaScript build wrote ${results.length} files`);
 		return;
 	}
 
-	if (command === "build-ts-all") {
+	if (command === "build-ast-all") {
 		const diagnostics = orderedResults.flatMap((result) =>
 			checkPointCore(programWithDependencyDeclarations(result, graph)).map((diagnostic) => ({ ...diagnostic, file: result.input })),
 		);
@@ -250,16 +271,16 @@ async function runProjectCommand(command: string) {
 			process.exit(1);
 		}
 		for (const result of orderedResults) {
-			const output = tsOutputFor(result.input);
+			const output = astOutputFor(result.input);
 			const outputPath = resolve(process.cwd(), output);
 			await Bun.$`mkdir -p ${dirname(outputPath)}`.quiet();
-			await Bun.write(outputPath, emitPointCoreTypeScript(programWithTypeScriptImports(result, graph)));
+			await Bun.write(outputPath, `${JSON.stringify(result.program, null, 2)}\n`);
 		}
-		console.log(`Point core TypeScript build wrote ${results.length} files`);
+		console.log(`Point core AST build wrote ${results.length} files`);
 		return;
 	}
 
-	if (command === "build-js-all") {
+	if (command === "build-ts-all") {
 		const diagnostics = orderedResults.flatMap((result) =>
 			checkPointCore(programWithDependencyDeclarations(result, graph)).map((diagnostic) => ({ ...diagnostic, file: result.input })),
 		);
@@ -268,12 +289,12 @@ async function runProjectCommand(command: string) {
 			process.exit(1);
 		}
 		for (const result of orderedResults) {
-			const output = jsOutputFor(result.input);
+			const output = tsOutputFor(result.input);
 			const outputPath = resolve(process.cwd(), output);
 			await Bun.$`mkdir -p ${dirname(outputPath)}`.quiet();
-			await Bun.write(outputPath, emitPointCoreJavaScript(programWithTypeScriptImports(result, graph)));
+			await Bun.write(outputPath, emitPointCoreTypeScript(programWithTypeScriptImports(result, graph)));
 		}
-		console.log(`Point core JavaScript build wrote ${results.length} files`);
+		console.log(`Point core TypeScript build wrote ${results.length} files`);
 		return;
 	}
 
@@ -358,8 +379,8 @@ async function runPointTests(program: PointCoreProgram, input: string): Promise<
 			(declaration.semantic?.name.startsWith("test") || declaration.name.startsWith("test")),
 	);
 	if (tests.length === 0) return { file: input, ok: true, tests: [] };
-	const testOutput = resolve(tmpdir(), `point-test-${Date.now()}-${Math.random().toString(16).slice(2)}.ts`);
-	await Bun.write(testOutput, emitPointCoreTypeScript(program));
+	const testOutput = resolve(tmpdir(), `point-test-${Date.now()}-${Math.random().toString(16).slice(2)}.js`);
+	await Bun.write(testOutput, emitPointCoreJavaScript(program));
 	const mod = await import(pathToFileUrl(testOutput));
 	const results = [];
 	for (const test of tests) {
@@ -498,6 +519,15 @@ function jsOutputFor(input: string): string {
 	return `${GENERATED_DIR}/${name}.js`;
 }
 
+function astOutputFor(input: string): string {
+	return outputFor(input);
+}
+
+function pyOutputFor(input: string): string {
+	const name = outputBaseName(input);
+	return `${GENERATED_DIR}/${name}.py`;
+}
+
 function outputBaseName(input: string): string {
 	return normalizeInput(input).split("/").pop()?.replace(/\.point$/, "") ?? "program";
 }

package/src/core/emit-javascript.ts

@@ -8,6 +8,8 @@ import type {
 	PointCoreTypeDeclaration,
 	PointCoreValueDeclaration,
 } from "./ast.ts";
+import type { PointSemanticRouteDeclaration } from "../semantic/ast.ts";
+import { semanticFunctionName } from "../semantic/naming.ts";
 
 const BINARY_OPERATORS: Record<string, string> = {
 	and: "&&",
@@ -16,13 +18,22 @@ const BINARY_OPERATORS: Record<string, string> = {
 
 /** Emit JavaScript from a core AST program (no type syntax). Production path: parsePointSource → check → emit. */
 export function emitPointCoreJavaScript(program: PointCoreProgram): string {
+	const routes = program.semanticSource?.declarations.filter((declaration): declaration is PointSemanticRouteDeclaration => declaration.kind === "route") ?? [];
+	const routeServeCommand = program.declarations.find((declaration) => declaration.kind === "function" && isRouteServeCommand(declaration));
 	const lines: string[] = [];
 	lines.push("// Generated by Point. Do not edit directly.");
 	if (program.module) lines.push(`// Point module: ${program.module}`);
 	lines.push("");
 	for (const declaration of program.declarations) {
+		if (declaration.kind === "function" && declaration.semantic?.kind === "command" && routes.length > 0 && isRouteServeCommand(declaration)) {
+			lines.push(...emitRouteServeCommand(declaration), "");
+			continue;
+		}
 		lines.push(...emitDeclaration(declaration), "");
 	}
+	if (routes.length > 0 && routeServeCommand) {
+		lines.push(...emitRouteServerRuntime(routes), "");
+	}
 	return `${trimTrailingBlankLines(lines).join("\n")}\n`;
 }
 
@@ -122,3 +133,54 @@ function trimTrailingBlankLines(lines: string[]): string[] {
 	while (lines.at(-1) === "") lines.pop();
 	return lines;
 }
+
+function isRouteServeCommand(declaration: PointCoreFunctionDeclaration): boolean {
+	return declaration.semantic?.name === "serve store readiness" || declaration.name === "serveStoreReadinessCommand";
+}
+
+function emitRouteServeCommand(declaration: PointCoreFunctionDeclaration): string[] {
+	const asyncPrefix = declaration.semantic?.kind === "command" ? "async " : "";
+	return [
+		`export ${asyncPrefix}function ${declaration.name}(${declaration.params.map(emitParam).join(", ")}) {`,
+		"  const port = Number(process.env.PORT ?? 3456);",
+		"  const server = Bun.serve({ port, fetch: createPointRouteFetchHandler() });",
+		"  console.log(`Store readiness listening on http://localhost:${server.port}`);",
+		"  await new Promise(() => {});",
+		"}",
+	];
+}
+
+function emitRouteServerRuntime(routes: PointSemanticRouteDeclaration[]): string[] {
+	const matchers = routes.map((route) => {
+		const handlerName = semanticFunctionName(route.name, "route", "route");
+		const pattern = route.path.replace(/:[A-Za-z][A-Za-z0-9_]*/g, "([^/]+)").replace(/\//g, "\\/");
+		const argExpressions = route.inputs.map((_input, index) => `match[${index + 1}]`);
+		return {
+			method: route.method.toUpperCase(),
+			pattern,
+			handlerName,
+			argExpressions,
+		};
+	});
+	const matchLines = matchers.flatMap((matcher) => [
+		`  if (req.method === ${JSON.stringify(matcher.method)} && new RegExp(${JSON.stringify(`^${matcher.pattern}$`)}).test(url.pathname)) {`,
+		`    const match = url.pathname.match(new RegExp(${JSON.stringify(`^${matcher.pattern}$`)}));`,
+		`    const body = ${matcher.handlerName}(${matcher.argExpressions.join(", ")});`,
+		'    return new Response(typeof body === "string" ? body : body, { headers: { "content-type": "application/json" } });',
+		"  }",
+	]);
+	return [
+		"export function createPointRouteFetchHandler() {",
+		"  return async (req) => {",
+		"    const url = new URL(req.url);",
+		...matchLines,
+		'    return new Response(JSON.stringify({ error: "Not found" }), { status: 404, headers: { "content-type": "application/json" } });',
+		"  };",
+		"}",
+		"",
+		"export function startRoutesServer() {",
+		"  const port = Number(process.env.PORT ?? 3456);",
+		"  return Bun.serve({ port, fetch: createPointRouteFetchHandler() });",
+		"}",
+	];
+}

package/src/core/emit-python.ts

@@ -0,0 +1,173 @@
+import type {
+	PointCoreDeclaration,
+	PointCoreExpression,
+	PointCoreFunctionDeclaration,
+	PointCoreParameter,
+	PointCorePrimitiveType,
+	PointCoreProgram,
+	PointCoreStatement,
+	PointCoreTypeDeclaration,
+	PointCoreTypeExpression,
+	PointCoreValueDeclaration,
+} from "./ast.ts";
+
+const BINARY_OPERATORS: Record<string, string> = {
+	and: "and",
+	or: "or",
+};
+
+const UNSUPPORTED_SEMANTIC_KINDS = new Set(["view", "route", "action", "workflow", "command"]);
+
+/** Emit Python from a core AST program (pure logic modules). Production path: parsePointSource → check → emit. */
+export function emitPointCorePython(program: PointCoreProgram): string {
+	const lines: string[] = [];
+	lines.push("# Generated by Point. Do not edit directly.");
+	if (program.module) lines.push(`# Point module: ${program.module}`);
+	lines.push("");
+	lines.push("from __future__ import annotations");
+	lines.push("");
+	if (program.declarations.some((declaration) => declaration.kind === "type")) {
+		lines.push("from typing import TypedDict");
+		lines.push("");
+	}
+	for (const declaration of program.declarations) {
+		const emitted = emitDeclaration(declaration);
+		if (emitted.length > 0) lines.push(...emitted, "");
+	}
+	return `${trimTrailingBlankLines(lines).join("\n")}\n`;
+}
+
+function emitDeclaration(declaration: PointCoreDeclaration): string[] {
+	if (declaration.kind === "import") {
+		const moduleName = declaration.from.replace(/^\.\//, "").replace(/-/g, "_");
+		return [`from ${toPythonModuleName(moduleName)} import ${declaration.names.join(", ")}`];
+	}
+	if (declaration.kind === "external") {
+		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 === "type") return emitType(declaration);
+	if (declaration.kind === "value") return [emitValue(declaration)];
+	if (declaration.semantic && UNSUPPORTED_SEMANTIC_KINDS.has(declaration.semantic.kind)) {
+		return [`# Point: ${declaration.semantic.kind} blocks are not supported in Python emit yet`];
+	}
+	return emitFunction(declaration);
+}
+
+function emitType(declaration: PointCoreTypeDeclaration): string[] {
+	return [
+		`class ${declaration.name}(TypedDict):`,
+		...declaration.fields.map((field) => `    ${field.name}: ${emitTypeExpression(field.type)}`),
+	];
+}
+
+function emitFunction(declaration: PointCoreFunctionDeclaration): string[] {
+	const asyncPrefix = declaration.semantic?.kind === "action" || declaration.semantic?.kind === "workflow" || declaration.semantic?.kind === "command" ? "async " : "";
+	return [
+		`${asyncPrefix}def ${declaration.name}(${declaration.params.map(emitParam).join(", ")}) -> ${emitReturnType(declaration)}:`,
+		...indentLines(declaration.body.flatMap((statement) => emitStatement(statement, declaration.semantic?.kind))),
+	];
+}
+
+function emitReturnType(declaration: PointCoreFunctionDeclaration): string {
+	if (declaration.semantic?.kind === "action" || declaration.semantic?.kind === "workflow" || declaration.semantic?.kind === "command") {
+		return emitTypeExpression(declaration.returnType);
+	}
+	return emitTypeExpression(declaration.returnType);
+}
+
+function emitStatement(statement: PointCoreStatement, semanticKind?: string): string[] {
+	if (statement.kind === "return") {
+		if (semanticKind === "view") return ["# Point: view return values are not supported in Python emit yet", "return \"\""];
+		return [statement.value ? `return ${emitExpression(statement.value)}` : "return"];
+	}
+	if (statement.kind === "value") return [emitValue(statement)];
+	if (statement.kind === "assignment") return [`${statement.name} ${statement.operator} ${emitExpression(statement.value)}`];
+	if (statement.kind === "if") {
+		const lines = [`if ${emitCondition(statement.condition)}:`, ...indentLines(statement.thenBody.flatMap((child) => emitStatement(child, semanticKind)))];
+		if (statement.elseBody.length > 0) {
+			lines.push("else:", ...indentLines(statement.elseBody.flatMap((child) => emitStatement(child, semanticKind))));
+		}
+		return lines;
+	}
+	if (statement.kind === "for") {
+		return [`for ${statement.itemName} in ${emitExpression(statement.iterable)}:`, ...indentLines(statement.body.flatMap((child) => emitStatement(child, semanticKind)))];
+	}
+	return [emitExpression(statement.value)];
+}
+
+function emitValue(declaration: PointCoreValueDeclaration): string {
+	return `${declaration.name}: ${emitTypeExpression(declaration.type)} = ${emitExpression(declaration.value)}`;
+}
+
+function emitParam(param: PointCoreParameter): string {
+	return `${param.name}: ${emitTypeExpression(param.type)}`;
+}
+
+function emitTypeExpression(type: PointCoreTypeExpression): string {
+	if (type.name === "List") return `list[${type.args[0] ? emitTypeExpression(type.args[0]) : "object"}]`;
+	if (type.name === "Maybe") return `${type.args[0] ? emitTypeExpression(type.args[0]) : "object"} | None`;
+	if (type.name === "Or") return type.args.map(emitTypeExpression).join(" | ");
+	if (type.name === "Error") return "dict[str, str]";
+	if (isPrimitiveType(type.name)) return emitPrimitiveType(type.name);
+	return type.name;
+}
+
+function emitPrimitiveType(type: PointCorePrimitiveType): string {
+	if (type === "Text") return "str";
+	if (type === "Int") return "int";
+	if (type === "Float") return "float";
+	if (type === "Bool") return "bool";
+	return "None";
+}
+
+function emitExpression(expression: PointCoreExpression): string {
+	if (expression.kind === "literal") return emitLiteral(expression.value);
+	if (expression.kind === "identifier") return expression.name;
+	if (expression.kind === "list") return `[${expression.items.map(emitExpression).join(", ")}]`;
+	if (expression.kind === "record") {
+		return `{${expression.fields.map((field) => `"${field.name}": ${emitExpression(field.value)}`).join(", ")}}`;
+	}
+	if (expression.kind === "await") return `await ${emitExpression(expression.value)}`;
+	if (expression.kind === "property") return `${emitExpression(expression.target)}[${JSON.stringify(expression.name)}]`;
+	if (expression.kind === "call") {
+		if (expression.callee === "Error") {
+			const message = expression.args[0] ? emitExpression(expression.args[0]) : '""';
+			return `{"message": ${message}}`;
+		}
+		return `${expression.callee}(${expression.args.map(emitExpression).join(", ")})`;
+	}
+	const operator = BINARY_OPERATORS[expression.operator] ?? expression.operator;
+	return `(${emitExpression(expression.left)} ${operator} ${emitExpression(expression.right)})`;
+}
+
+function emitLiteral(value: unknown): string {
+	if (value === null) return "None";
+	if (value === true) return "True";
+	if (value === false) return "False";
+	if (typeof value === "string") return JSON.stringify(value);
+	return String(value);
+}
+
+function emitCondition(expression: PointCoreExpression): string {
+	const emitted = emitExpression(expression);
+	return emitted.startsWith("(") && emitted.endsWith(")") ? emitted.slice(1, -1) : emitted;
+}
+
+function toPythonModuleName(from: string): string {
+	return from.replace(/\.ts$/, "").replace(/\.js$/, "").replace(/\.py$/, "");
+}
+
+function isPrimitiveType(type: string): type is PointCorePrimitiveType {
+	return type === "Text" || type === "Int" || type === "Float" || type === "Bool" || type === "Void";
+}
+
+function indentLines(lines: string[]): string[] {
+	return lines.map((line) => `    ${line}`);
+}
+
+function trimTrailingBlankLines(lines: string[]): string[] {
+	while (lines.at(-1) === "") lines.pop();
+	return lines;
+}

package/src/core/emit-typescript.ts

@@ -68,8 +68,11 @@ function emitFunction(declaration: PointCoreFunctionDeclaration): string[] {
 
 function emitStatement(statement: PointCoreStatement, semanticKind?: string): string[] {
 	if (statement.kind === "return") {
-		if (semanticKind === "view" && statement.value?.kind === "literal" && typeof statement.value.value === "string") {
-			return [`return <>${escapeJsxText(statement.value.value)}</>;`];
+		if (semanticKind === "view" && statement.value) {
+			if (statement.value.kind === "literal" && typeof statement.value.value === "string") {
+				return [`return <>${escapeJsxText(statement.value.value)}</>;`];
+			}
+			return [`return <>{${emitExpression(statement.value)}}</>;`];
 		}
 		return [statement.value ? `return ${emitExpression(statement.value)};` : "return;"];
 	}

package/src/core/index.ts

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

package/src/lsp/analyze.ts

@@ -31,6 +31,61 @@ export interface LspHover {
 	contents: string;
 }
 
+export interface LspCompletionItem {
+	label: string;
+	kind: number;
+	detail?: string;
+}
+
+const BLOCK_KEYWORDS = [
+	"module",
+	"use",
+	"record",
+	"calculation",
+	"rule",
+	"label",
+	"external",
+	"action",
+	"policy",
+	"view",
+	"route",
+	"workflow",
+	"command",
+];
+
+const STATEMENT_KEYWORDS = [
+	"input",
+	"output",
+	"return",
+	"when",
+	"otherwise",
+	"add",
+	"subtract",
+	"set",
+	"for",
+	"each",
+	"in",
+	"starts",
+	"at",
+	"as",
+	"to",
+	"from",
+	"is",
+	"render",
+	"method",
+	"path",
+	"step",
+	"await",
+	"touches",
+	"and",
+	"or",
+	"none",
+	"true",
+	"false",
+];
+
+const TYPE_KEYWORDS = ["Text", "Int", "Float", "Bool", "Void", "List", "Maybe"];
+
 export interface PointDocumentAnalysis {
 	diagnostics: LspDiagnostic[];
 	symbols: PointSemanticSymbol[];
@@ -128,6 +183,79 @@ export function formatPointDocument(source: string): string {
 	}
 }
 
+export function completionsForPosition(source: string, line: number, column: number): LspCompletionItem[] {
+	const analysis = analyzePointSource(source);
+	const lines = source.split(/\r?\n/);
+	const lineText = lines[line - 1] ?? "";
+	const before = lineText.slice(0, Math.max(0, column - 1));
+	const items: LspCompletionItem[] = [];
+	const seen = new Set<string>();
+	const add = (label: string, kind: number, detail?: string) => {
+		if (seen.has(label)) return;
+		seen.add(label);
+		items.push({ label, kind, detail });
+	};
+
+	if (/^\s*$/.test(before)) {
+		for (const keyword of BLOCK_KEYWORDS) add(keyword, 14);
+	}
+
+	for (const keyword of [...STATEMENT_KEYWORDS, ...TYPE_KEYWORDS]) add(keyword, 14);
+	for (const symbol of analysis.symbols) {
+		const kind =
+			symbol.kind === "field" ? 5 : symbol.kind === "record" ? 7 : symbol.kind === "param" ? 6 : 3;
+		add(symbol.name, kind, symbol.kind);
+	}
+
+	return items;
+}
+
+export function renameSymbolInDocument(
+	source: string,
+	line: number,
+	column: number,
+	newName: string,
+): { range: LspRange; newText: string } | null {
+	const analysis = analyzePointSource(source);
+	const symbol = symbolAtPoint(analysis.symbols, line, column);
+	if (!symbol?.span || !newName.trim()) return null;
+	const oldName = symbol.name;
+	if (oldName === newName) {
+		return { range: pointSpanToLspRange(symbol.span), newText: oldName };
+	}
+	const escaped = oldName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const updated = source.replace(new RegExp(escaped, "g"), newName);
+	if (updated === source) return null;
+	return {
+		range: fullDocumentRange(source),
+		newText: updated,
+	};
+}
+
+export function prepareRenameAtPosition(
+	source: string,
+	line: number,
+	column: number,
+): { range: LspRange; placeholder: string } | null {
+	const analysis = analyzePointSource(source);
+	const symbol = symbolAtPoint(analysis.symbols, line, column);
+	if (!symbol?.span) return null;
+	return {
+		range: pointSpanToLspRange(symbol.span),
+		placeholder: symbol.name,
+	};
+}
+
+function fullDocumentRange(text: string): LspRange {
+	const lines = text.split(/\r?\n/);
+	const lastLine = Math.max(0, lines.length - 1);
+	const lastCharacter = lines[lastLine]?.length ?? 0;
+	return {
+		start: { line: 0, character: 0 },
+		end: { line: lastLine, character: lastCharacter },
+	};
+}
+
 function toLspDiagnostic(diagnostic: PointCoreDiagnostic): LspDiagnostic {
 	const range = diagnostic.span
 		? pointSpanToLspRange(diagnostic.span)

package/src/lsp/server.ts

@@ -1,18 +1,32 @@
 import {
 	analyzePointSource,
+	completionsForPosition,
 	definitionForPosition,
 	formatPointDocument,
 	hoverForPosition,
 	lspPositionToPoint,
 	outlineSymbols,
+	prepareRenameAtPosition,
+	renameSymbolInDocument,
 	type LspRange,
 } from "./analyze.ts";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import { LspReader, writeMessage, type JsonRpcMessage } from "./protocol.ts";
 
 type DocumentState = { version: number; text: string };
 
 const documents = new Map<string, DocumentState>();
 
+function lspVersion(): string {
+	try {
+		const pkgPath = join(import.meta.dir, "../../package.json");
+		return (JSON.parse(readFileSync(pkgPath, "utf8")) as { version: string }).version;
+	} catch {
+		return "0.0.0";
+	}
+}
+
 export async function runPointLspServer(): Promise<void> {
 	const reader = new LspReader();
 	for await (const message of reader.messages()) {
@@ -29,8 +43,10 @@ async function handleMessage(message: JsonRpcMessage): Promise<void> {
 				definitionProvider: true,
 				hoverProvider: true,
 				documentFormattingProvider: true,
+				completionProvider: { triggerCharacters: [".", " "] },
+				renameProvider: { prepareProvider: true },
 			},
-			serverInfo: { name: "point-lsp", version: "0.0.9" },
+			serverInfo: { name: "point-lsp", version: lspVersion() },
 		});
 		return;
 	}
@@ -130,6 +146,65 @@ async function handleMessage(message: JsonRpcMessage): Promise<void> {
 		return;
 	}
 
+	if (message.method === "textDocument/completion") {
+		const params = message.params as {
+			textDocument: { uri: string };
+			position: { line: number; character: number };
+		};
+		const document = documents.get(params.textDocument.uri);
+		if (!document) {
+			respond(message.id, { isIncomplete: false, items: [] });
+			return;
+		}
+		const point = lspPositionToPoint(params.position.line, params.position.character);
+		const items = completionsForPosition(document.text, point.line, point.column);
+		respond(message.id, { isIncomplete: false, items });
+		return;
+	}
+
+	if (message.method === "textDocument/prepareRename") {
+		const params = message.params as {
+			textDocument: { uri: string };
+			position: { line: number; character: number };
+		};
+		const document = documents.get(params.textDocument.uri);
+		if (!document) {
+			respond(message.id, null);
+			return;
+		}
+		const point = lspPositionToPoint(params.position.line, params.position.character);
+		const prepared = prepareRenameAtPosition(document.text, point.line, point.column);
+		respond(message.id, prepared);
+		return;
+	}
+
+	if (message.method === "textDocument/rename") {
+		const params = message.params as {
+			textDocument: { uri: string };
+			position: { line: number; character: number };
+			newName: string;
+		};
+		const document = documents.get(params.textDocument.uri);
+		if (!document) {
+			respond(message.id, null);
+			return;
+		}
+		const point = lspPositionToPoint(params.position.line, params.position.character);
+		const edit = renameSymbolInDocument(document.text, point.line, point.column, params.newName);
+		if (!edit) {
+			respond(message.id, null);
+			return;
+		}
+		documents.set(params.textDocument.uri, { version: document.version, text: edit.newText });
+		publishDiagnostics(params.textDocument.uri);
+		respond(message.id, {
+			changes: {
+				[params.textDocument.uri]: [edit],
+			},
+		});
+		return;
+	}
+
 	if (message.id !== undefined) {
 		respond(message.id, null);
 	}

package/src/semantic/expressions.ts

@@ -138,9 +138,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 +182,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[] = [];