@hatchingpoint/point 0.0.13 → 0.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchingpoint/point",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "private": false,
   "type": "module",
   "description": "Point language compiler and CLI.",
@@ -26,7 +26,11 @@
     "./cli": "./src/cli.ts",
     "./core": "./src/core/index.ts",
     "./std/json": "./src/std/json.ts",
-    "./std/http": "./src/std/http.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/cli.ts

@@ -7,6 +7,7 @@ import { createSemanticIndex, explainSemanticRef, mapPublicDiagnostics } from ".
 import { emitPointCoreTypeScript } from "./emit-typescript.ts";
 import { emitPointCoreJavaScript } from "./emit-javascript.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";
@@ -23,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;
@@ -176,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)}`);
@@ -434,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 =
@@ -524,9 +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(/^[/\\]/, "");
+	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/packages.ts

@@ -1,4 +1,5 @@
-import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { existsSync, readdirSync } from "node:fs";
 import { join, relative, resolve } from "node:path";
 
 export const POINT_MANIFEST = "point.json";
@@ -29,15 +30,36 @@ export interface ParsedDependencySpec {
 	locator: string;
 }
 
+export interface ParsedNpmLocator {
+	name: string;
+	version?: string;
+}
+
+export function parseNpmLocator(locator: string): ParsedNpmLocator {
+	if (locator.startsWith("@")) {
+		const slash = locator.indexOf("/");
+		if (slash < 0) {
+			throw new Error(`Invalid npm package name "${locator}". Scoped packages use @scope/name.`);
+		}
+		const rest = locator.slice(slash + 1);
+		const versionAt = rest.indexOf("@");
+		if (versionAt >= 0) {
+			return { name: `${locator.slice(0, slash + 1 + versionAt)}`, version: rest.slice(versionAt + 1) };
+		}
+		return { name: locator };
+	}
+	const versionAt = locator.lastIndexOf("@");
+	if (versionAt > 0) {
+		return { name: locator.slice(0, versionAt), version: locator.slice(versionAt + 1) };
+	}
+	return { name: locator };
+}
+
 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.`;
+	throw new Error(`Invalid dependency spec "${spec}". Use workspace:<path>, file:<path>, or npm:<package>[@version].`);
 }
 
 export async function readPointManifest(cwd = process.cwd()): Promise<PointManifest> {
@@ -74,9 +96,71 @@ export function normalizePackagePath(cwd: string, rawPath: string): string {
 	return relative(cwd, absolute).split("\\").join("/") || ".";
 }
 
-export function resolveDependencySpec(spec: string, cwd = process.cwd()): PointLockPackage {
+export function locatePointPackageRoot(pkgDir: string): string {
+	if (existsSync(join(pkgDir, POINT_MANIFEST))) return pkgDir;
+	const srcDir = join(pkgDir, "src");
+	if (existsSync(srcDir) && readdirSync(srcDir).some((name) => name.endsWith(".point"))) return pkgDir;
+	if (readdirSync(pkgDir).some((name) => name.endsWith(".point"))) return pkgDir;
+	throw new Error(`Point package at ${pkgDir} has no ${POINT_MANIFEST} or src/*.point modules`);
+}
+
+export function resolveNpmPackagePath(cwd: string, packageName: string): string | null {
+	const direct = join(cwd, "node_modules", ...packageName.split("/"));
+	if (existsSync(join(direct, "package.json"))) return direct;
+	try {
+		const req = createRequire(join(cwd, "package.json"));
+		const pkgJson = req.resolve(`${packageName}/package.json`);
+		return resolve(pkgJson, "..");
+	} catch {
+		return null;
+	}
+}
+
+async function readInstalledNpmVersion(pkgDir: string): Promise<string | null> {
+	const pkgJsonPath = join(pkgDir, "package.json");
+	if (!existsSync(pkgJsonPath)) return null;
+	const pkg = (await Bun.file(pkgJsonPath).json()) as { version?: string };
+	return pkg.version ?? null;
+}
+
+export async function ensureNpmPackage(cwd: string, packageName: string, version?: string): Promise<string> {
+	const installed = resolveNpmPackagePath(cwd, packageName);
+	if (installed) {
+		const installedVersion = await readInstalledNpmVersion(installed);
+		if (!version || installedVersion === version) return installed;
+	}
+	const installSpec = version ? `${packageName}@${version}` : packageName;
+	const result = await Bun.$`npm install ${installSpec} --prefix ${cwd} --no-save --no-package-lock`.quiet().nothrow();
+	if (result.exitCode !== 0) {
+		const detail = result.stderr.toString().trim() || result.stdout.toString().trim();
+		throw new Error(`npm install failed for ${installSpec}: ${detail || "unknown error"}`);
+	}
+	const resolved = resolveNpmPackagePath(cwd, packageName);
+	if (!resolved) {
+		throw new Error(`npm package "${packageName}" was not found under node_modules/ after install`);
+	}
+	if (version) {
+		const installedVersion = await readInstalledNpmVersion(resolved);
+		if (installedVersion && installedVersion !== version) {
+			throw new Error(`npm package "${packageName}" resolved to ${installedVersion}, expected ${version}`);
+		}
+	}
+	return resolved;
+}
+
+export async function resolveNpmDependencySpec(spec: string, cwd = process.cwd()): Promise<PointLockPackage> {
 	const parsed = parseDependencySpec(spec);
-	if (parsed.kind === "npm") throw new Error(npmDependencyNotSupportedMessage(spec));
+	if (parsed.kind !== "npm") throw new Error(`Expected npm: spec, got ${spec}`);
+	const { name, version } = parseNpmLocator(parsed.locator);
+	const pkgDir = await ensureNpmPackage(cwd, name, version);
+	locatePointPackageRoot(pkgDir);
+	const npmVersion = (await readInstalledNpmVersion(pkgDir)) ?? version ?? "npm";
+	return { version: npmVersion, path: normalizePackagePath(cwd, pkgDir) };
+}
+
+export async function resolveDependencySpec(spec: string, cwd = process.cwd()): Promise<PointLockPackage> {
+	const parsed = parseDependencySpec(spec);
+	if (parsed.kind === "npm") return resolveNpmDependencySpec(spec, cwd);
 	const path = normalizePackagePath(cwd, parsed.locator);
 	return { version: parsed.kind, path };
 }
@@ -89,7 +173,7 @@ export async function resolveLockFromManifest(manifest: PointManifest, cwd = pro
 		},
 	};
 	for (const [name, spec] of Object.entries(manifest.dependencies ?? {})) {
-		packages[name] = resolveDependencySpec(spec, cwd);
+		packages[name] = await resolveDependencySpec(spec, cwd);
 		const entry = packages[name];
 		if (!entry.path) continue;
 		const nestedManifestPath = join(cwd, entry.path, POINT_MANIFEST);
@@ -123,7 +207,12 @@ export function packageRootFromLock(lock: PointLock | null, packageName: string)
 	return null;
 }
 
-export function modulePathFromLock(lock: PointLock | null, moduleName: string): string {
+function modulePathCandidates(root: string, modulePath: string): string[] {
+	const segments = modulePath.replaceAll(".", "/");
+	return [`${root}/${segments}.point`, `${root}/src/${segments}.point`];
+}
+
+export function modulePathFromLock(lock: PointLock | null, moduleName: string, cwd = process.cwd()): string {
 	const dot = moduleName.indexOf(".");
 	if (dot < 0) {
 		throw new Error(`Use declarations without from must target package modules: ${moduleName}`);
@@ -134,5 +223,8 @@ export function modulePathFromLock(lock: PointLock | null, moduleName: string):
 	if (!root) {
 		throw new Error(`Unknown package "${packageName}" in ${moduleName}. Add it with: point add ${packageName} <spec>`);
 	}
-	return `${root}/${modulePath.replaceAll(".", "/")}.point`;
+	for (const candidate of modulePathCandidates(root, modulePath)) {
+		if (existsSync(join(cwd, candidate))) return candidate;
+	}
+	return modulePathCandidates(root, modulePath)[0]!;
 }

package/src/core/run-bridge.ts

@@ -0,0 +1,93 @@
+import type { PointCoreProgram } from "./ast.ts";
+import { emitPointCoreJavaScript } from "./emit-javascript.ts";
+import { isPureLogicProgram } from "./emit-python.ts";
+
+/** Pure logic with no imports or externals can run in-memory without a temp module file. */
+export function canBundleRunInMemory(program: PointCoreProgram): boolean {
+	if (!isPureLogicProgram(program)) return false;
+	if (program.declarations.some((declaration) => declaration.kind === "import" || declaration.kind === "external")) return false;
+	if (program.semanticSource?.uses?.length) return false;
+	const emitted = emitPointCoreJavaScript(program);
+	if (/^\s*import\s/m.test(emitted)) return false;
+	return !hasUnresolvedCallTargets(emitted);
+}
+
+const BUILTIN_CALL_TARGETS = new Set([
+	"Array",
+	"Boolean",
+	"JSON",
+	"Math",
+	"Number",
+	"Object",
+	"Promise",
+	"String",
+	"console",
+	"fetch",
+	"parseInt",
+	"parseFloat",
+]);
+
+const NON_CALL_KEYWORDS = new Set([
+	"async",
+	"await",
+	"catch",
+	"delete",
+	"export",
+	"for",
+	"function",
+	"if",
+	"import",
+	"instanceof",
+	"new",
+	"return",
+	"switch",
+	"throw",
+	"typeof",
+	"void",
+	"while",
+	"with",
+	"yield",
+]);
+
+function hasUnresolvedCallTargets(source: string): boolean {
+	const defined = new Set<string>();
+	for (const match of source.matchAll(/(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/g)) defined.add(match[1]!);
+	for (const match of source.matchAll(/\b([A-Za-z_$][\w$]*)\s*\(/g)) {
+		const name = match[1]!;
+		if (NON_CALL_KEYWORDS.has(name) || BUILTIN_CALL_TARGETS.has(name) || defined.has(name)) continue;
+		return true;
+	}
+	return false;
+}
+
+export function bundleJavaScriptForEval(source: string): { body: string; exports: string[] } {
+	const exports: string[] = [];
+	const bodyLines: string[] = [];
+	for (const line of source.split(/\r?\n/)) {
+		if (/^\s*import\s/.test(line)) continue;
+		const fnMatch = line.match(/^export\s+(async\s+)?function\s+([A-Za-z_$][\w$]*)/);
+		if (fnMatch) {
+			exports.push(fnMatch[2]!);
+			bodyLines.push(line.replace(/^export\s+/, ""));
+			continue;
+		}
+		const bindingMatch = line.match(/^export\s+(const|let|var)\s+([A-Za-z_$][\w$]*)/);
+		if (bindingMatch) {
+			exports.push(bindingMatch[2]!);
+			bodyLines.push(line.replace(/^export\s+/, ""));
+			continue;
+		}
+		bodyLines.push(line);
+	}
+	return { body: bodyLines.join("\n"), exports };
+}
+
+export async function executeBundledEntry(program: PointCoreProgram, entryName: string): Promise<unknown> {
+	const { body, exports } = bundleJavaScriptForEval(emitPointCoreJavaScript(program));
+	if (!exports.includes(entryName)) throw new Error(`Entrypoint ${entryName} was not emitted.`);
+	const factory = new Function(`"use strict";\n${body}\nreturn { ${exports.join(", ")} };`);
+	const mod = factory() as Record<string, unknown>;
+	const entry = mod[entryName];
+	if (typeof entry !== "function") throw new Error(`Entrypoint ${entryName} was not a function.`);
+	return await (entry as () => unknown)();
+}

package/src/std/env.ts

@@ -0,0 +1,4 @@
+export function envGet(name: string): string | null {
+	const value = process.env[name];
+	return value === undefined ? null : value;
+}

package/src/std/fs.ts

@@ -0,0 +1,19 @@
+import { readFileSync, writeFileSync } from "node:fs";
+
+type PointStdError = { message: string };
+
+export function readFile(path: string): string | PointStdError {
+	try {
+		return readFileSync(path, "utf8");
+	} catch (error) {
+		return { message: error instanceof Error ? error.message : String(error) };
+	}
+}
+
+export function writeFile(path: string, contents: string): void | PointStdError {
+	try {
+		writeFileSync(path, contents, "utf8");
+	} catch (error) {
+		return { message: error instanceof Error ? error.message : String(error) };
+	}
+}

package/src/std/text.ts

@@ -0,0 +1,15 @@
+export function textLength(value: string): number {
+	return value.length;
+}
+
+export function textContains(value: string, search: string): boolean {
+	return value.includes(search);
+}
+
+export function textSplit(value: string, separator: string): string[] {
+	return value.split(separator);
+}
+
+export function textTrim(value: string): string {
+	return value.trim();
+}

package/src/std/time.ts

@@ -0,0 +1,15 @@
+export function now(): string {
+	return new Date().toISOString();
+}
+
+export async function sleep(ms: number): Promise<void> {
+	await Bun.sleep(ms);
+}
+
+export function formatTime(value: string): string {
+	const date = new Date(value);
+	if (Number.isNaN(date.getTime())) {
+		return value;
+	}
+	return date.toUTCString();
+}