@creationix/rex 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tim Caswell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,50 @@
+# @creationix/rex
+
+Rex compiler and parser package.
+
+## Install
+
+```sh
+bun add -g @creationix/rex
+```
+
+## Publish to npm
+
+From `packages/rex-lang`:
+
+```sh
+npm whoami
+bun run prepublishOnly
+npm publish --access public
+```
+
+Or one-off dry run:
+
+```sh
+bun run pack:dry-run
+```
+
+## CLI
+
+```sh
+rex --help
+rex --expr "when x do y end"
+rex --file input.rex
+cat input.rex | rex
+rex --expr "a and b" --ir
+rex --expr "x = method + path x" --minify-names --dedupe-values
+```
+
+## Programmatic API
+
+```ts
+import { compile, parseToIR, optimizeIR, encodeIR } from "@creationix/rex";
+
+const source = "when x do y else z end";
+const encoded = compile(source);
+const optimized = compile(source, { optimize: true, minifyNames: true, dedupeValues: true });
+
+const ir = parseToIR(source);
+const optimizedIR = optimizeIR(ir);
+const reEncoded = encodeIR(optimizedIR);
+```

package/package.json

@@ -0,0 +1,56 @@
+{
+	"name": "@creationix/rex",
+	"version": "0.1.0",
+	"description": "Compiler and parser for the Rex language",
+	"keywords": [
+		"rex",
+		"dsl",
+		"compiler",
+		"parser",
+		"configuration"
+	],
+	"type": "module",
+	"bin": {
+		"rex": "./rex-cli.ts"
+	},
+	"main": "rex.ts",
+	"types": "./rex.ts",
+	"exports": {
+		".": "./rex.ts"
+	},
+	"files": [
+		"README.md",
+		"LICENSE",
+		"rex.ts",
+		"rex-compile.ts",
+		"rex-cli.ts",
+		"rex.ohm",
+		"rex.ohm-bundle.js",
+		"rex.ohm-bundle.d.ts",
+		"rexc-interpreter.ts"
+	],
+	"scripts": {
+		"test": "bun test",
+		"build:grammar": "ohm generateBundles --withTypes rex.ohm",
+		"compile": "bun run rex-compile.ts",
+		"verify:docs": "bun run verify-doc-examples.ts",
+		"pack:dry-run": "npm pack --dry-run",
+		"prepublishOnly": "bun run build:grammar && bun test && npm run pack:dry-run"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/creationix/rex",
+		"directory": "packages/rex-lang"
+	},
+	"license": "MIT",
+	"dependencies": {
+		"ohm-js": "^17.1.0"
+	},
+	"devDependencies": {
+		"@ohm-js/cli": "^2.0.1",
+		"@types/bun": "latest"
+	}
+}

package/rex-cli.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+
+import "./rex-compile.ts";

package/rex-compile.ts

@@ -0,0 +1,196 @@
+import { compile, parseToIR } from "./rex.ts";
+import { dirname, resolve } from "node:path";
+
+type CliOptions = {
+	expr?: string;
+	file?: string;
+	out?: string;
+	ir: boolean;
+	minifyNames: boolean;
+	dedupeValues: boolean;
+	dedupeMinBytes?: number;
+	domainRefs: Record<string, number>;
+	help: boolean;
+};
+
+type DomainSchema = {
+	globals?: Record<string, unknown>;
+};
+
+function parseArgs(argv: string[]): CliOptions {
+	const options: CliOptions = {
+		ir: false,
+		minifyNames: false,
+		dedupeValues: false,
+		domainRefs: {},
+		help: false,
+	};
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+		if (!arg) continue;
+		if (arg === "--help" || arg === "-h") {
+			options.help = true;
+			continue;
+		}
+		if (arg === "--ir") {
+			options.ir = true;
+			continue;
+		}
+		if (arg === "--minify-names" || arg === "-m") {
+			options.minifyNames = true;
+			continue;
+		}
+		if (arg === "--dedupe-values") {
+			options.dedupeValues = true;
+			continue;
+		}
+		if (arg === "--dedupe-min-bytes") {
+			const value = argv[index + 1];
+			if (!value) throw new Error("Missing value for --dedupe-min-bytes");
+			const parsed = Number(value);
+			if (!Number.isInteger(parsed) || parsed < 1) throw new Error("--dedupe-min-bytes must be a positive integer");
+			options.dedupeMinBytes = parsed;
+			index += 1;
+			continue;
+		}
+		if (arg === "--domain-extension") {
+			const value = argv[index + 1];
+			if (!value) throw new Error("Missing value for --domain-extension");
+			options.domainRefs[value] = 0;
+			index += 1;
+			continue;
+		}
+		if (arg === "--domain-ref") {
+			const value = argv[index + 1];
+			if (!value) throw new Error("Missing value for --domain-ref");
+			const separator = value.indexOf("=");
+			if (separator < 1 || separator === value.length - 1) {
+				throw new Error("--domain-ref expects NAME=ID (for example: headers=0)");
+			}
+			const name = value.slice(0, separator);
+			const idText = value.slice(separator + 1);
+			const id = Number(idText);
+			if (!Number.isInteger(id) || id < 0) throw new Error(`Invalid domain ref id in --domain-ref '${value}'`);
+			options.domainRefs[name] = id;
+			index += 1;
+			continue;
+		}
+		if (arg === "--expr" || arg === "-e") {
+			const value = argv[index + 1];
+			if (!value) throw new Error("Missing value for --expr");
+			options.expr = value;
+			index += 1;
+			continue;
+		}
+		if (arg === "--file" || arg === "-f") {
+			const value = argv[index + 1];
+			if (!value) throw new Error("Missing value for --file");
+			options.file = value;
+			index += 1;
+			continue;
+		}
+		if (arg === "--out" || arg === "-o") {
+			const value = argv[index + 1];
+			if (!value) throw new Error("Missing value for --out");
+			options.out = value;
+			index += 1;
+			continue;
+		}
+		throw new Error(`Unknown option: ${arg}`);
+	}
+	return options;
+}
+
+function usage() {
+	return [
+		"Compile high-level Rex to compact encoding (rexc).",
+		"",
+		"Usage:",
+		"  bun run rex:compile --expr \"when x do y end\"",
+		"  bun run rex:compile --file input.rex",
+		"  cat input.rex | bun run rex:compile",
+		"",
+		"Options:",
+		"  -e, --expr <source>   Compile an inline expression/program",
+		"  -f, --file <path>     Compile source from a file",
+		"  -o, --out <path>      Write output to file instead of stdout",
+		"      --ir              Output lowered IR JSON instead of compact encoding",
+		"  -m, --minify-names    Minify local variable names in compiled output",
+		"      --dedupe-values   Deduplicate large repeated values using forward pointers",
+		"      --dedupe-min-bytes <n>  Minimum encoded value bytes for pointer dedupe (default: 4)",
+		"      --domain-extension <name>  Map domain symbol name to ref 0 (apostrophe)",
+		"      --domain-ref <name=id>    Map domain symbol name to a specific ref id",
+		"  -h, --help            Show this message",
+	].join("\n");
+}
+
+async function readStdin(): Promise<string> {
+	return Bun.stdin.text();
+}
+
+async function resolveSource(options: CliOptions): Promise<string> {
+	if (options.expr && options.file) throw new Error("Use only one of --expr or --file");
+	if (options.expr) return options.expr;
+	if (options.file) return Bun.file(options.file).text();
+	if (!process.stdin.isTTY) {
+		const piped = await readStdin();
+		if (piped.trim().length > 0) return piped;
+	}
+	throw new Error("No input provided. Use --expr, --file, or pipe source via stdin.");
+}
+
+async function loadDomainRefsFromFolder(folderPath: string): Promise<Record<string, number>> {
+	const schemaPath = resolve(folderPath, "rex-domain.json");
+	const file = Bun.file(schemaPath);
+	if (!(await file.exists())) return {};
+
+	const parsed = JSON.parse(await file.text()) as DomainSchema;
+	if (!parsed || typeof parsed !== "object" || !parsed.globals || typeof parsed.globals !== "object") {
+		throw new Error(`Invalid rex-domain.json at ${schemaPath}: expected { globals: { ... } }`);
+	}
+
+	const refs: Record<string, number> = {};
+	let nextRef = 0;
+	for (const name of Object.keys(parsed.globals)) {
+		refs[name] = nextRef;
+		nextRef += 1;
+	}
+	return refs;
+}
+
+async function resolveDomainRefs(options: CliOptions): Promise<Record<string, number>> {
+	const baseFolder = options.file ? dirname(resolve(options.file)) : process.cwd();
+	const autoRefs = await loadDomainRefsFromFolder(baseFolder);
+	return { ...autoRefs, ...options.domainRefs };
+}
+
+async function main() {
+	const options = parseArgs(Bun.argv.slice(2));
+	if (options.help) {
+		console.log(usage());
+		return;
+	}
+
+	const source = await resolveSource(options);
+	const domainRefs = await resolveDomainRefs(options);
+	const output = options.ir
+		? JSON.stringify(parseToIR(source), null, 2)
+		: compile(source, {
+			minifyNames: options.minifyNames,
+			dedupeValues: options.dedupeValues,
+			dedupeMinBytes: options.dedupeMinBytes,
+			domainRefs,
+		});
+
+	if (options.out) {
+		await Bun.write(options.out, `${output}\n`);
+		return;
+	}
+	console.log(output);
+}
+
+await main().catch((error) => {
+	const message = error instanceof Error ? error.message : String(error);
+	console.error(`rex:compile error: ${message}`);
+	process.exit(1);
+});