recipe-tmlanguage 0.3.3 → 0.3.5

package/bin/{recipe-tmlang.mjs → cli.mjs}

@@ -1,13 +1,34 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
-import { mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { cli, command, flag } from "@kjanat/dreamcli";
 import { dirname, resolve } from "node:path";
-import { cwd, exit } from "node:process";
 import { fileURLToPath } from "node:url";
-import { cli, command, flag } from "dreamcli";
 import { COUNTERS, NUMBER_WORDS, PERIODS, PERIOD_PLURALS } from "tree-sitter-recipe/grammar/dutch";
 import { COMPOUNDING, COMPOUNDING_MULTIWORD, CONDITIONAL, CONDITIONAL_MULTIWORD, DISPENSING, DISPENSING_MULTIWORD, FORMS, FORMS_MULTIWORD, FREQUENCY, ROUTE, ROUTE_MULTIWORD, TIMING, TIMING_MULTIWORD, WARNING } from "tree-sitter-recipe/grammar/latin";
 import { UNITS } from "tree-sitter-recipe/grammar/units";
+import { mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { cwd, exit } from "node:process";
+import { readFile } from "node:fs/promises";
+//#region bin/lib/utils.ts
+const require$1 = createRequire(import.meta.url);
+const toPath = (resolved) => resolved.startsWith("file:") ? fileURLToPath(resolved) : resolved;
+function packageDir(specifier) {
+	return resolve(dirname(toPath(require$1.resolve(specifier))));
+}
+function resolveImportMeta(specifier) {
+	return toPath(import.meta.resolve(specifier));
+}
+/**
+* Default path of the generated grammar: `recipe.tmLanguage.json` at the
+* package root. Anchored on `#pkg` (package.json / deno.json — always present)
+* rather than `#tmLang`, because the grammar is generated + gitignored and may
+* not exist yet on a fresh checkout, and `import.meta.resolve` throws on a
+* missing target. Existence is enforced later, where the file is actually read.
+*/
+function defaultGrammarPath() {
+	return resolve(dirname(resolveImportMeta("#pkg")), "recipe.tmLanguage.json");
+}
+//#endregion
 //#region src/grammar.ts
 /**
 * @file Pure grammar builder — imports the tree-sitter-recipe vocabulary and
@@ -16,6 +37,8 @@ import { UNITS } from "tree-sitter-recipe/grammar/units";
 *
 * Scopes are standard TextMate names with a `.recipe` suffix so themes paint
 * recipe blocks without a custom theme shipment.
+*
+* @module recipe-tmlanguage/src/grammar
 */
 const SCOPE = {
 	rxMarker: "keyword.control.directive.rx.recipe",
@@ -45,7 +68,7 @@ const SCOPE = {
 const REGEX_METACHARS = /[.*+?^${}()|[\]\\]/g;
 const escapeRegex = (s) => s.replace(REGEX_METACHARS, "\\$&");
 const alt = (items) => [...new Set(items)].sort((a, b) => b.length - a.length).map(escapeRegex).join("|");
-const altMultiword = (items) => [...new Set(items)].sort((a, b) => b.length - a.length).map((s) => s.replace(/\./g, "\\.").replace(/\s+/g, "\\s+")).join("|");
+const altMultiword = (items) => [...new Set(items)].sort((a, b) => b.length - a.length).map((s) => escapeRegex(s).replace(/\s+/g, "\\s+")).join("|");
 const wb = (pattern) => `(?<![\\w.])(?:${pattern})(?![\\w.])`;
 function buildGrammar() {
 	const doseMatch = {
@@ -267,6 +290,61 @@ function serializeGrammar(g, indent) {
 	return `${JSON.stringify(g, null, indent === "tab" ? "	" : indent)}\n`;
 }
 //#endregion
+//#region bin/commands/generate.ts
+const indentOf = (raw) => raw === "tab" ? "tab" : Number(raw);
+const DEFAULT_OUT$1 = defaultGrammarPath();
+const generateCmd = command("generate").description("Build the TextMate grammar from the tree-sitter-recipe vocabulary").flag("out", flag.string().alias("o").default(DEFAULT_OUT$1).describe("Output JSON path")).flag("indent", flag.enum([
+	"tab",
+	"2",
+	"4"
+]).default("tab").describe("JSON indent")).flag("quiet", flag.boolean().alias("q").default(false).describe("Suppress stats on success")).action(({ flags, out }) => {
+	const { grammar, stats } = buildGrammar();
+	const serialized = serializeGrammar(grammar, indentOf(flags.indent));
+	const outAbs = resolve(cwd(), flags.out);
+	mkdirSync(dirname(outAbs), { recursive: true });
+	writeFileSync(outAbs, serialized);
+	const { json, jsonMode, log } = out;
+	if (jsonMode) {
+		json({
+			ok: true,
+			outPath: outAbs,
+			bytes: serialized.length,
+			stats
+		});
+		return;
+	}
+	if (flags.quiet) return;
+	log(`wrote ${outAbs}`);
+	log(`  ${stats.topLevelPatterns} top-level patterns · ${serialized.length} bytes`);
+	const v = stats.vocab;
+	log(`  vocab: ${v.frequency} frequency · ${v.timing.single}+${v.timing.multi} timing · ${v.route.single}+${v.route.multi} route · ${v.dispensing.single}+${v.dispensing.multi} dispensing · ${v.forms.single}+${v.forms.multi} forms · ${v.compounding.single}+${v.compounding.multi} compounding · ${v.conditional.single}+${v.conditional.multi} conditional · ${v.warning} warning · ${v.units} units`);
+});
+//#endregion
+//#region src/deps/oniguruma.ts
+const require = createRequire(import.meta.url);
+const oniguruma = require("vscode-oniguruma");
+let loadPromise;
+function loadOniguruma() {
+	loadPromise ??= (async () => {
+		const wasm = await readFile(require.resolve("vscode-oniguruma/release/onig.wasm"));
+		await oniguruma.loadWASM(wasm);
+	})();
+	return loadPromise;
+}
+async function createOnigLib() {
+	await loadOniguruma();
+	return {
+		createOnigScanner(patterns) {
+			return oniguruma.createOnigScanner(patterns);
+		},
+		createOnigString(string) {
+			return oniguruma.createOnigString(string);
+		}
+	};
+}
+const { loadWASM, createOnigScanner, createOnigString, OnigScanner, OnigString } = oniguruma;
+const { parseRawGrammar, Registry, INITIAL } = createRequire(import.meta.url)("vscode-textmate");
+//#endregion
 //#region src/verifier.ts
 /**
 * @file Pure verifier — tokenizes tree-sitter-recipe's own highlight fixtures
@@ -275,10 +353,9 @@ function serializeGrammar(g, indent) {
 *
 * No CLI concerns here; the caller supplies paths and decides how to present
 * the result (text table / JSON / exit code).
+*
+* @module recipe-tmlanguage/src/verifier
 */
-const require = createRequire(import.meta.url);
-const oniguruma = require("vscode-oniguruma");
-const { parseRawGrammar, Registry } = require("vscode-textmate");
 const CAPTURE_EXPECTS = {
 	"keyword.directive": "keyword.control.directive",
 	"keyword.repeat": "keyword.other.frequency",
@@ -331,16 +408,11 @@ function parseFixture(content, name) {
 	};
 }
 async function verify(opts) {
-	const wasmBin = readFileSync(opts.onigWasmPath);
-	await oniguruma.loadWASM(wasmBin.buffer);
-	const onigLib = Promise.resolve({
-		createOnigScanner: (patterns) => new oniguruma.OnigScanner(patterns),
-		createOnigString: (s) => new oniguruma.OnigString(s)
-	});
+	const onigLib = createOnigLib();
 	const rawGrammar = parseRawGrammar(readFileSync(opts.grammarPath, "utf-8"), opts.grammarPath);
 	const grammar = await new Registry({
 		onigLib,
-		loadGrammar: async () => null
+		loadGrammar: () => Promise.resolve(null)
 	}).addGrammar(rawGrammar);
 	const result = {
 		pass: 0,
@@ -380,87 +452,55 @@ async function verify(opts) {
 	return result;
 }
 //#endregion
-//#region package.json
-var version = "0.3.3";
-var homepage = "https://github.com/kjanat/recipe-tmlanguage#recipe-tmlanguage";
-var repository = {
-	"type": "git",
-	"url": "git+https://github.com/kjanat/recipe-tmlanguage.git"
-};
-//#endregion
-//#region bin/recipe-tmlang.ts
-/**
-* recipe-tmlang — TextMate grammar generator & verifier for recipe-tmlanguage.
-*
-* Subcommands
-* - generate:   Build dist/recipe.tmLanguage.json from the tree-sitter-recipe vocab.
-* - verify:     Tokenize tree-sitter-recipe's highlight fixtures and assert scopes.
-*
-* Zero manual argparse — argument parsing, help, and completions all come from
-* {@link https://github.com/kjanat/dreamcli | DreamCLI}. `--json` is a DreamCLI built-in;
-* we branch on {@linkcode Out.jsonMode}.
-*/
-const DEFAULT_OUT = `${resolve(import.meta.dirname, "..")}/recipe.tmLanguage.json`;
-const DEFAULT_FIXTURES_DIR = resolve(resolve(dirname(fileURLToPath(import.meta.resolve("tree-sitter-recipe/package.json")))), "test/highlight");
-const DEFAULT_ONIG_WASM = fileURLToPath(import.meta.resolve("vscode-oniguruma/release/onig.wasm"));
-const indentOf = (raw) => raw === "tab" ? "tab" : Number(raw);
-const generate = command("generate").description("Build the TextMate grammar from the tree-sitter-recipe vocabulary").flag("out", flag.string().alias("o").default(DEFAULT_OUT).describe("Output JSON path")).flag("indent", flag.enum([
-	"tab",
-	"2",
-	"4"
-]).default("tab").describe("JSON indent")).flag("quiet", flag.boolean().alias("q").default(false).describe("Suppress stats on success")).action(({ flags, out }) => {
-	const { grammar, stats } = buildGrammar();
-	const serialized = serializeGrammar(grammar, indentOf(flags.indent));
-	const outAbs = resolve(cwd(), flags.out);
-	mkdirSync(dirname(outAbs), { recursive: true });
-	writeFileSync(outAbs, serialized);
-	if (out.jsonMode) {
-		out.json({
-			ok: true,
-			outPath: outAbs,
-			bytes: serialized.length,
-			stats
-		});
-		return;
-	}
-	if (flags.quiet) return;
-	out.log(`wrote ${outAbs}`);
-	out.log(`  ${stats.topLevelPatterns} top-level patterns · ${serialized.length} bytes`);
-	const v = stats.vocab;
-	out.log(`  vocab: ${v.frequency} frequency · ${v.timing.single}+${v.timing.multi} timing · ${v.route.single}+${v.route.multi} route · ${v.dispensing.single}+${v.dispensing.multi} dispensing · ${v.forms.single}+${v.forms.multi} forms · ${v.compounding.single}+${v.compounding.multi} compounding · ${v.conditional.single}+${v.conditional.multi} conditional · ${v.warning} warning · ${v.units} units`);
-});
-const verifyCmd = command("verify").description("Tokenize tree-sitter-recipe highlight fixtures and assert scope matches").flag("grammar", flag.string().alias("g").default(DEFAULT_OUT).describe("Path to .tmLanguage.json")).flag("fixtures", flag.string().alias("f").default(DEFAULT_FIXTURES_DIR).describe("Directory of .recipe fixtures")).flag("onig-wasm", flag.string().default(DEFAULT_ONIG_WASM).describe("Path to oniguruma WASM")).flag("max-failures", flag.number().default(40).describe("Max failures to print (0 = all)")).action(async ({ flags, out }) => {
+//#region bin/commands/verify.ts
+const DEFAULT_FIXTURES_DIR = resolve(packageDir("tree-sitter-recipe/package.json"), "test/highlight");
+const DEFAULT_OUT = defaultGrammarPath();
+const verifyCmd = command("verify").description("Tokenize tree-sitter-recipe highlight fixtures and assert scope matches").flag("grammar", flag.string().alias("g").default(DEFAULT_OUT).describe("Path to .tmLanguage.json")).flag("fixtures", flag.string().alias("f").default(DEFAULT_FIXTURES_DIR).describe("Directory of .recipe fixtures")).flag("max-failures", flag.number().default(40).describe("Max failures to print (0 = all)")).action(async ({ flags, out }) => {
 	const result = await verify({
 		grammarPath: resolve(cwd(), flags.grammar),
-		fixturesDir: resolve(cwd(), flags.fixtures),
-		onigWasmPath: resolve(cwd(), flags["onig-wasm"])
+		fixturesDir: resolve(cwd(), flags.fixtures)
 	});
 	const failuresLen = result.failures.length;
-	if (out.jsonMode) {
-		out.json(result);
+	const { json, jsonMode, setExitCode, log } = out;
+	if (jsonMode) {
+		json(result);
 		if (failuresLen > 0) {
-			out.setExitCode(1);
+			setExitCode(1);
 			exit();
 		}
 		return;
 	}
-	out.log(`${result.pass} / ${result.total} assertions pass`);
+	log(`${result.pass} / ${result.total} assertions pass`);
 	if (failuresLen === 0) return;
-	out.log("");
-	out.log("── failures ──");
+	log("");
+	log("── failures ──");
 	const limit = flags["max-failures"] === 0 ? failuresLen : flags["max-failures"];
 	for (const f of result.failures.slice(0, limit)) {
 		const gotStr = f.got ? f.got.filter((s) => s !== "source.recipe").join(" · ") || "(root only)" : "(no token)";
-		out.log(`  ${f.fixture}:${f.line}:${f.col}  expected ${f.capture}  got [${gotStr}]`);
+		log(`  ${f.fixture}:${f.line}:${f.col}  expected ${f.capture}  got [${gotStr}]`);
 	}
-	if (failuresLen > limit) out.log(`  … +${failuresLen - limit} more`);
-	out.setExitCode(1);
+	if (failuresLen > limit) log(`  … +${failuresLen - limit} more`);
+	setExitCode(1);
 });
-const app = cli("recipe-tmlang").packageJson({
-	repository,
-	homepage,
-	version
-}).links().description("TextMate grammar generator & verifier for the recipe DSL").command(generate).command(verifyCmd).completions();
+//#endregion
+//#region bin/cli.ts
+/**
+* recipe-tmlang — TextMate grammar generator & verifier for recipe-tmlanguage.
+*
+* Subcommands
+* - generate:   Build dist/recipe.tmLanguage.json from the tree-sitter-recipe vocab.
+* - verify:     Tokenize tree-sitter-recipe's highlight fixtures and assert scopes.
+*
+* Zero manual argparse — argument parsing, help, and completions all come from
+* {@link https://github.com/kjanat/dreamcli | DreamCLI}. `--json` is a DreamCLI built-in;
+* we branch on {@linkcode out.jsonMode | https://dreamcli.kjanat.com/reference/symbols/main/Out#jsonmode}.
+*
+* @module recipe-tmlanguage/bin
+*/
+const app = cli("recipe-tmlanguage").manifest({
+	from: import.meta.url,
+	files: ["package.json", "deno.json"]
+}).links().description("TextMate grammar generator & verifier for the recipe DSL").command(generateCmd).command(verifyCmd).completions();
 if (import.meta.main) app.run();
 //#endregion
-export { app };
+export {};

package/bin/cli.ts

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+/**
+ * recipe-tmlang — TextMate grammar generator & verifier for recipe-tmlanguage.
+ *
+ * Subcommands
+ * - generate:   Build dist/recipe.tmLanguage.json from the tree-sitter-recipe vocab.
+ * - verify:     Tokenize tree-sitter-recipe's highlight fixtures and assert scopes.
+ *
+ * Zero manual argparse — argument parsing, help, and completions all come from
+ * {@link https://github.com/kjanat/dreamcli | DreamCLI}. `--json` is a DreamCLI built-in;
+ * we branch on {@linkcode out.jsonMode | https://dreamcli.kjanat.com/reference/symbols/main/Out#jsonmode}.
+ *
+ * @module recipe-tmlanguage/bin
+ */
+import { cli } from "@kjanat/dreamcli";
+import { generateCmd } from "./commands/generate.ts";
+import { verifyCmd } from "./commands/verify.ts";
+
+const app = cli("recipe-tmlanguage")
+	.manifest({ from: import.meta.url, files: ["package.json", "deno.json"] })
+	.links()
+	.description("TextMate grammar generator & verifier for the recipe DSL")
+	.command(generateCmd)
+	.command(verifyCmd)
+	.completions();
+
+if (import.meta.main) app.run();

package/bin/commands/generate.ts

@@ -0,0 +1,36 @@
+import { defaultGrammarPath } from "#bin/lib/utils.ts";
+import { buildGrammar, serializeGrammar } from "#src/grammar.ts";
+import { command, flag } from "@kjanat/dreamcli";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { cwd } from "node:process";
+
+const indentOf = (raw: string): "tab" | number => (raw === "tab" ? "tab" : Number(raw));
+const DEFAULT_OUT = defaultGrammarPath();
+
+export const generateCmd = command("generate")
+	.description("Build the TextMate grammar from the tree-sitter-recipe vocabulary")
+	.flag("out", flag.string().alias("o").default(DEFAULT_OUT).describe("Output JSON path"))
+	.flag("indent", flag.enum(["tab", "2", "4"]).default("tab").describe("JSON indent"))
+	.flag("quiet", flag.boolean().alias("q").default(false).describe("Suppress stats on success"))
+	.action(({ flags, out }) => {
+		const { grammar, stats } = buildGrammar();
+		const serialized = serializeGrammar(grammar, indentOf(flags.indent));
+		const outAbs = resolve(cwd(), flags.out);
+		mkdirSync(dirname(outAbs), { recursive: true });
+		writeFileSync(outAbs, serialized);
+		const { json, jsonMode, log } = out;
+
+		if (jsonMode) {
+			json({ ok: true, outPath: outAbs, bytes: serialized.length, stats });
+			return;
+		}
+		if (flags.quiet) return;
+
+		log(`wrote ${outAbs}`);
+		log(`  ${stats.topLevelPatterns} top-level patterns · ${serialized.length} bytes`);
+		const v = stats.vocab;
+		log(
+			`  vocab: ${v.frequency} frequency · ${v.timing.single}+${v.timing.multi} timing · ${v.route.single}+${v.route.multi} route · ${v.dispensing.single}+${v.dispensing.multi} dispensing · ${v.forms.single}+${v.forms.multi} forms · ${v.compounding.single}+${v.compounding.multi} compounding · ${v.conditional.single}+${v.conditional.multi} conditional · ${v.warning} warning · ${v.units} units`,
+		);
+	});

package/bin/commands/verify.ts

@@ -0,0 +1,48 @@
+import { defaultGrammarPath, packageDir } from "#bin/lib/utils.ts";
+import { verify } from "#src/verifier.ts";
+import { command, flag } from "@kjanat/dreamcli";
+import { resolve } from "node:path";
+import { cwd, exit } from "node:process";
+
+const DEFAULT_FIXTURES_DIR = resolve(packageDir("tree-sitter-recipe/package.json"), "test/highlight");
+const DEFAULT_OUT = defaultGrammarPath();
+
+export const verifyCmd = command("verify")
+	.description("Tokenize tree-sitter-recipe highlight fixtures and assert scope matches")
+	.flag("grammar", flag.string().alias("g").default(DEFAULT_OUT).describe("Path to .tmLanguage.json"))
+	.flag("fixtures", flag.string().alias("f").default(DEFAULT_FIXTURES_DIR).describe("Directory of .recipe fixtures"))
+	.flag("max-failures", flag.number().default(40).describe("Max failures to print (0 = all)"))
+	.action(async ({ flags, out }) => {
+		const result = await verify({
+			grammarPath: resolve(cwd(), flags.grammar),
+			fixturesDir: resolve(cwd(), flags.fixtures),
+		});
+		const failuresLen = result.failures.length;
+		const { json, jsonMode, setExitCode, log } = out;
+
+		if (jsonMode) {
+			json(result);
+			if (failuresLen > 0) {
+				setExitCode(1);
+				exit();
+			}
+			return;
+		}
+
+		log(`${result.pass} / ${result.total} assertions pass`);
+		if (failuresLen === 0) return;
+
+		log("");
+		log("── failures ──");
+		const limit = flags["max-failures"] === 0 ? failuresLen : flags["max-failures"];
+		for (const f of result.failures.slice(0, limit)) {
+			const gotStr = f.got
+				? f.got.filter((s) => s !== "source.recipe").join(" · ") || "(root only)"
+				: "(no token)";
+			log(`  ${f.fixture}:${f.line}:${f.col}  expected ${f.capture}  got [${gotStr}]`);
+		}
+		if (failuresLen > limit) {
+			log(`  … +${failuresLen - limit} more`);
+		}
+		setExitCode(1);
+	});

package/bin/lib/utils.ts

@@ -0,0 +1,29 @@
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const require = createRequire(import.meta.url);
+
+const toPath = (resolved: string) =>
+	resolved.startsWith("file:")
+		? fileURLToPath(resolved)
+		: resolved;
+
+export function packageDir(specifier: string): string {
+	return resolve(dirname(toPath(require.resolve(specifier))));
+}
+
+export function resolveImportMeta(specifier: string): string {
+	return toPath(import.meta.resolve(specifier));
+}
+
+/**
+ * Default path of the generated grammar: `recipe.tmLanguage.json` at the
+ * package root. Anchored on `#pkg` (package.json / deno.json — always present)
+ * rather than `#tmLang`, because the grammar is generated + gitignored and may
+ * not exist yet on a fresh checkout, and `import.meta.resolve` throws on a
+ * missing target. Existence is enforced later, where the file is actually read.
+ */
+export function defaultGrammarPath(): string {
+	return resolve(dirname(resolveImportMeta("#pkg")), "recipe.tmLanguage.json");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "recipe-tmlanguage",
-	"version": "0.3.3",
+	"version": "0.3.5",
 	"description": "TextMate grammar for the recipe (.recipe) pharmacological notation language.",
 	"keywords": [
 		"dreamcli",
@@ -21,17 +21,20 @@
 	},
 	"type": "module",
 	"imports": {
+		"#bin/*": "./bin/*",
+		"#src/*": "./src/*",
+		"#deps/*": "./src/deps/*",
 		"#pkg": "./package.json",
-		"#grammar": "./src/grammar.ts",
-		"#verifier": "./src/verifier.ts"
+		"#tmLang": "./recipe.tmLanguage.json"
 	},
 	"exports": {
 		".": "./recipe.tmLanguage.json",
+		"./bin": "./bin/cli.mjs",
 		"./package.json": "./package.json"
 	},
 	"main": "./recipe.tmLanguage.json",
 	"module": "./recipe.tmLanguage.json",
-	"bin": "bin/recipe-tmlang.mjs",
+	"bin": "bin/cli.mjs",
 	"directories": {
 		"lib": "/src",
 		"bin": "/bin"
@@ -52,15 +55,17 @@
 		"generate": "run recipe-tmlang generate",
 		"lint": "biome lint",
 		"prepack": "bun run generate && bun run bundle",
-		"recipe-tmlang": "bun bin/recipe-tmlang.ts",
+		"recipe-tmlang": "bun bin/cli.ts",
+		"test": "bun test",
 		"typecheck": "tsc --noEmit",
-		"verify": "run recipe-tmlang verify"
+		"verify": "run recipe-tmlang verify",
+		"version": "node bin/cli.mjs --version"
 	},
 	"dependencies": {
-		"dreamcli": "npm:@kjanat/dreamcli@^2.4.0",
+		"@kjanat/dreamcli": "^2.5.0",
 		"tree-sitter-recipe": "^0.3.1",
 		"vscode-oniguruma": "^2.0.1",
-		"vscode-textmate": "^9.2.0"
+		"vscode-textmate": "^9.3.2"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "^2.5.1",

package/src/deps/oniguruma.ts

@@ -0,0 +1,35 @@
+// src/deps/oniguruma.ts
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import type { IOnigLib } from "./textmate.ts";
+
+const require = createRequire(import.meta.url);
+const oniguruma: typeof import("vscode-oniguruma") = require("vscode-oniguruma");
+
+let loadPromise: Promise<void> | undefined;
+
+export function loadOniguruma(): Promise<void> {
+	loadPromise ??= (async () => {
+		const wasmPath = require.resolve("vscode-oniguruma/release/onig.wasm");
+		const wasm = await readFile(wasmPath);
+
+		await oniguruma.loadWASM(wasm);
+	})();
+
+	return loadPromise;
+}
+
+export async function createOnigLib(): Promise<IOnigLib> {
+	await loadOniguruma();
+
+	return {
+		createOnigScanner(patterns) {
+			return oniguruma.createOnigScanner(patterns);
+		},
+		createOnigString(string) {
+			return oniguruma.createOnigString(string);
+		},
+	};
+}
+
+export const { loadWASM, createOnigScanner, createOnigString, OnigScanner, OnigString } = oniguruma;

package/src/deps/textmate.ts

@@ -0,0 +1,8 @@
+import { createRequire } from "node:module";
+
+export type { IOnigLib, StateStack } from "vscode-textmate";
+const require = createRequire(import.meta.url);
+
+const textmate: typeof import("vscode-textmate") = require("vscode-textmate");
+
+export const { parseRawGrammar, Registry, INITIAL } = textmate;

package/src/grammar.ts

@@ -5,6 +5,8 @@
  *
  * Scopes are standard TextMate names with a `.recipe` suffix so themes paint
  * recipe blocks without a custom theme shipment.
+ *
+ * @module recipe-tmlanguage/src/grammar
  */
 import { COUNTERS, NUMBER_WORDS, PERIOD_PLURALS, PERIODS } from "tree-sitter-recipe/grammar/dutch";
 import {
@@ -74,7 +76,7 @@ const alt = (items: readonly string[]): string =>
 const altMultiword = (items: readonly string[]): string =>
 	[...new Set(items)]
 		.sort((a, b) => b.length - a.length)
-		.map((s) => s.replace(/\./g, "\\.").replace(/\s+/g, "\\s+"))
+		.map((s) => escapeRegex(s).replace(/\s+/g, "\\s+"))
 		.join("|");
 
 // Word boundary that treats `.` as part of the token so `a.c.` doesn't match

package/src/verifier.ts

@@ -5,17 +5,15 @@
  *
  * No CLI concerns here; the caller supplies paths and decides how to present
  * the result (text table / JSON / exit code).
+ *
+ * @module recipe-tmlanguage/src/verifier
  */
 import { readdirSync, readFileSync } from "node:fs";
-import { createRequire } from "node:module";
 import { resolve } from "node:path";
 
-import type { StateStack } from "vscode-textmate";
-
-const require = createRequire(import.meta.url);
-const oniguruma: typeof import("vscode-oniguruma") = require("vscode-oniguruma");
-const textmate: typeof import("vscode-textmate") = require("vscode-textmate");
-const { parseRawGrammar, Registry } = textmate;
+import { createOnigLib } from "#deps/oniguruma.ts";
+import type { StateStack } from "#deps/textmate.ts";
+import { parseRawGrammar, Registry } from "#deps/textmate.ts";
 
 // ── capture → scope mapping (inverse of grammar.ts SCOPE) ───────────────────
 // Fixtures speak tree-sitter capture names; the tokenizer speaks TextMate
@@ -57,7 +55,6 @@ export type VerifyResult = {
 export type VerifyOptions = {
 	grammarPath: string;
 	fixturesDir: string;
-	onigWasmPath: string;
 };
 
 // ── fixture parser ──────────────────────────────────────────────────────────
@@ -105,19 +102,13 @@ function parseFixture(content: string, name: string): { source: string; asserts:
 
 // ── main ────────────────────────────────────────────────────────────────────
 export async function verify(opts: VerifyOptions): Promise<VerifyResult> {
-	const wasmBin = readFileSync(opts.onigWasmPath);
-	await oniguruma.loadWASM(wasmBin.buffer as ArrayBuffer);
-
-	const onigLib = Promise.resolve({
-		createOnigScanner: (patterns: string[]) => new oniguruma.OnigScanner(patterns),
-		createOnigString: (s: string) => new oniguruma.OnigString(s),
-	});
+	const onigLib = createOnigLib();
 
 	const rawGrammar = parseRawGrammar(
 		readFileSync(opts.grammarPath, "utf-8"),
 		opts.grammarPath,
 	);
-	const registry = new Registry({ onigLib, loadGrammar: async () => null });
+	const registry = new Registry({ onigLib, loadGrammar: () => Promise.resolve(null) });
 	const grammar = await registry.addGrammar(rawGrammar);
 
 	const result: VerifyResult = { pass: 0, total: 0, failures: [] };

package/bin/recipe-tmlang.ts

@@ -1,106 +0,0 @@
-#!/usr/bin/env node
-/**
- * recipe-tmlang — TextMate grammar generator & verifier for recipe-tmlanguage.
- *
- * Subcommands
- * - generate:   Build dist/recipe.tmLanguage.json from the tree-sitter-recipe vocab.
- * - verify:     Tokenize tree-sitter-recipe's highlight fixtures and assert scopes.
- *
- * Zero manual argparse — argument parsing, help, and completions all come from
- * {@link https://github.com/kjanat/dreamcli | DreamCLI}. `--json` is a DreamCLI built-in;
- * we branch on {@linkcode Out.jsonMode}.
- */
-import { mkdirSync, writeFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { cwd, exit } from "node:process";
-import { fileURLToPath } from "node:url";
-
-import { cli, command, flag } from "dreamcli";
-import type { Out } from "dreamcli";
-
-import { buildGrammar, serializeGrammar } from "#grammar";
-import { verify } from "#verifier";
-
-import { homepage, repository, version } from "#pkg" with { type: "json" };
-
-const DEFAULT_OUT = `${resolve(import.meta.dirname, "..")}/recipe.tmLanguage.json`;
-
-const TS_RX_DIR = resolve(dirname(fileURLToPath(import.meta.resolve("tree-sitter-recipe/package.json"))));
-const DEFAULT_FIXTURES_DIR = resolve(TS_RX_DIR, "test/highlight");
-const DEFAULT_ONIG_WASM = fileURLToPath(import.meta.resolve("vscode-oniguruma/release/onig.wasm"));
-
-const indentOf = (raw: string): "tab" | number => (raw === "tab" ? "tab" : Number(raw));
-
-const generate = command("generate")
-	.description("Build the TextMate grammar from the tree-sitter-recipe vocabulary")
-	.flag("out", flag.string().alias("o").default(DEFAULT_OUT).describe("Output JSON path"))
-	.flag("indent", flag.enum(["tab", "2", "4"]).default("tab").describe("JSON indent"))
-	.flag("quiet", flag.boolean().alias("q").default(false).describe("Suppress stats on success"))
-	.action(({ flags, out }) => {
-		const { grammar, stats } = buildGrammar();
-		const serialized = serializeGrammar(grammar, indentOf(flags.indent));
-		const outAbs = resolve(cwd(), flags.out);
-		mkdirSync(dirname(outAbs), { recursive: true });
-		writeFileSync(outAbs, serialized);
-		if (out.jsonMode) {
-			out.json({ ok: true, outPath: outAbs, bytes: serialized.length, stats });
-			return;
-		}
-		if (flags.quiet) return;
-
-		out.log(`wrote ${outAbs}`);
-		out.log(`  ${stats.topLevelPatterns} top-level patterns · ${serialized.length} bytes`);
-		const v = stats.vocab;
-		out.log(
-			`  vocab: ${v.frequency} frequency · ${v.timing.single}+${v.timing.multi} timing · ${v.route.single}+${v.route.multi} route · ${v.dispensing.single}+${v.dispensing.multi} dispensing · ${v.forms.single}+${v.forms.multi} forms · ${v.compounding.single}+${v.compounding.multi} compounding · ${v.conditional.single}+${v.conditional.multi} conditional · ${v.warning} warning · ${v.units} units`,
-		);
-	});
-
-const verifyCmd = command("verify")
-	.description("Tokenize tree-sitter-recipe highlight fixtures and assert scope matches")
-	.flag("grammar", flag.string().alias("g").default(DEFAULT_OUT).describe("Path to .tmLanguage.json"))
-	.flag("fixtures", flag.string().alias("f").default(DEFAULT_FIXTURES_DIR).describe("Directory of .recipe fixtures"))
-	.flag("onig-wasm", flag.string().default(DEFAULT_ONIG_WASM).describe("Path to oniguruma WASM"))
-	.flag("max-failures", flag.number().default(40).describe("Max failures to print (0 = all)"))
-	.action(async ({ flags, out }) => {
-		const result = await verify({
-			grammarPath: resolve(cwd(), flags.grammar),
-			fixturesDir: resolve(cwd(), flags.fixtures),
-			onigWasmPath: resolve(cwd(), flags["onig-wasm"]),
-		});
-		const failuresLen = result.failures.length;
-
-		if (out.jsonMode) {
-			out.json(result);
-			if (failuresLen > 0) {
-				out.setExitCode(1);
-				exit();
-			}
-			return;
-		}
-
-		out.log(`${result.pass} / ${result.total} assertions pass`);
-		if (failuresLen === 0) return;
-
-		out.log("");
-		out.log("── failures ──");
-		const limit = flags["max-failures"] === 0 ? failuresLen : flags["max-failures"];
-		for (const f of result.failures.slice(0, limit)) {
-			const gotStr = f.got
-				? f.got.filter((s) => s !== "source.recipe").join(" · ") || "(root only)"
-				: "(no token)";
-			out.log(`  ${f.fixture}:${f.line}:${f.col}  expected ${f.capture}  got [${gotStr}]`);
-		}
-		if (failuresLen > limit) {
-			out.log(`  … +${failuresLen - limit} more`);
-		}
-		out.setExitCode(1);
-	});
-
-export const app = cli("recipe-tmlang").packageJson({ repository, homepage, version }).links()
-	.description("TextMate grammar generator & verifier for the recipe DSL")
-	.command(generate)
-	.command(verifyCmd)
-	.completions();
-
-if (import.meta.main) app.run();