@rejot-dev/thalo 0.1.0 → 0.2.1

package/dist/merge/driver.d.ts

@@ -31,14 +31,25 @@ interface MergeOptions {
  * It parses all three versions, matches entries, detects conflicts,
  * and produces a merged result.
  *
+ * This function is synchronous but requires the parser to be initialized first.
+ * Call `await initParser()` from `@rejot-dev/thalo/node` before using this function.
+ * Internally uses `parseDocument` which depends on the initialized parser.
+ *
  * @param base - Base version content (common ancestor)
  * @param ours - Our version content (local changes)
  * @param theirs - Their version content (incoming changes)
  * @param options - Merge options
  * @returns MergeResult with merged content and conflict information
+ * @throws Error if the parser has not been initialized
  *
  * @example
  * ```typescript
+ * import { initParser } from "@rejot-dev/thalo/node";
+ * import { mergeThaloFiles } from "@rejot-dev/thalo";
+ *
+ * // Initialize the parser first (required)
+ * await initParser();
+ *
  * const base = '2026-01-01T00:00Z define-entity lore "Lore"';
  * const ours = base + '\n2026-01-02T00:00Z create lore "My entry" ^entry1';
  * const theirs = base + '\n2026-01-03T00:00Z create lore "Their entry" ^entry2';

package/dist/merge/driver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"driver.d.ts","names":[],"sources":["../../src/merge/driver.ts"],"sourcesContent":[],"mappings":";;;;;;;AAWA;AA6CgB,UA7CC,YAAA,CA6Cc;;;;;;;;;;;;;;;;kBA3Bb;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BF,eAAA,uDAIL,eACR"}
+{"version":3,"file":"driver.d.ts","names":[],"sources":["../../src/merge/driver.ts"],"sourcesContent":[],"mappings":";;;;;;;AAWA;AAwDgB,UAxDC,YAAA,CAwDc;;;;;;;;;;;;;;;;kBAtCb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCF,eAAA,uDAIL,eACR"}

package/dist/merge/driver.js

@@ -1,5 +1,5 @@
 import { extractSourceFile } from "../ast/extract.js";
-import { parseDocument } from "../parser.js";
+import { parseDocument } from "../parser.node.js";
 import { matchEntries } from "./entry-matcher.js";
 import { detectConflicts } from "./conflict-detector.js";
 import { buildMergedResult } from "./merge-result-builder.js";
@@ -12,14 +12,25 @@ import { buildMergedResult } from "./merge-result-builder.js";
 * It parses all three versions, matches entries, detects conflicts,
 * and produces a merged result.
 *
+* This function is synchronous but requires the parser to be initialized first.
+* Call `await initParser()` from `@rejot-dev/thalo/node` before using this function.
+* Internally uses `parseDocument` which depends on the initialized parser.
+*
 * @param base - Base version content (common ancestor)
 * @param ours - Our version content (local changes)
 * @param theirs - Their version content (incoming changes)
 * @param options - Merge options
 * @returns MergeResult with merged content and conflict information
+* @throws Error if the parser has not been initialized
 *
 * @example
 * ```typescript
+* import { initParser } from "@rejot-dev/thalo/node";
+* import { mergeThaloFiles } from "@rejot-dev/thalo";
+*
+* // Initialize the parser first (required)
+* await initParser();
+*
 * const base = '2026-01-01T00:00Z define-entity lore "Lore"';
 * const ours = base + '\n2026-01-02T00:00Z create lore "My entry" ^entry1';
 * const theirs = base + '\n2026-01-03T00:00Z create lore "Their entry" ^entry2';

package/dist/merge/driver.js.map

@@ -1 +1 @@
-{"version":3,"file":"driver.js","names":["syntaxErrorConflicts: MergeConflict[]"],"sources":["../../src/merge/driver.ts"],"sourcesContent":["import { parseDocument } from \"../parser.js\";\nimport { extractSourceFile } from \"../ast/extract.js\";\nimport type { MergeResult } from \"./merge-result-builder.js\";\nimport type { MergeConflict, ConflictRule } from \"./conflict-detector.js\";\nimport { matchEntries } from \"./entry-matcher.js\";\nimport { detectConflicts } from \"./conflict-detector.js\";\nimport { buildMergedResult } from \"./merge-result-builder.js\";\n\n/**\n * Options for the merge driver\n */\nexport interface MergeOptions {\n  /**\n   * Conflict marker style\n   * - \"git\": Standard Git style (ours/theirs)\n   * - \"diff3\": Include base section\n   */\n  markerStyle?: \"git\" | \"diff3\";\n\n  /**\n   * Whether to include base in markers (diff3 style)\n   * Deprecated: Use markerStyle: \"diff3\" instead\n   */\n  showBase?: boolean;\n\n  /**\n   * Custom conflict detection rules\n   * Applied after default rules\n   */\n  conflictRules?: ConflictRule[];\n}\n\n/**\n * Perform three-way merge of thalo files\n *\n * This is the main entry point for the merge driver.\n * It parses all three versions, matches entries, detects conflicts,\n * and produces a merged result.\n *\n * @param base - Base version content (common ancestor)\n * @param ours - Our version content (local changes)\n * @param theirs - Their version content (incoming changes)\n * @param options - Merge options\n * @returns MergeResult with merged content and conflict information\n *\n * @example\n * ```typescript\n * const base = '2026-01-01T00:00Z define-entity lore \"Lore\"';\n * const ours = base + '\\n2026-01-02T00:00Z create lore \"My entry\" ^entry1';\n * const theirs = base + '\\n2026-01-03T00:00Z create lore \"Their entry\" ^entry2';\n *\n * const result = mergeThaloFiles(base, ours, theirs);\n * console.log(result.success); // true\n * console.log(result.content); // Merged content with both entries\n * ```\n */\nexport function mergeThaloFiles(\n  base: string,\n  ours: string,\n  theirs: string,\n  options: MergeOptions = {},\n): MergeResult {\n  try {\n    const baseDoc = parseDocument(base, { fileType: \"thalo\" });\n    const oursDoc = parseDocument(ours, { fileType: \"thalo\" });\n    const theirsDoc = parseDocument(theirs, { fileType: \"thalo\" });\n\n    const baseAst =\n      baseDoc.blocks.length > 0\n        ? extractSourceFile(baseDoc.blocks[0].tree.rootNode)\n        : { entries: [], syntaxErrors: [] };\n    const oursAst =\n      oursDoc.blocks.length > 0\n        ? extractSourceFile(oursDoc.blocks[0].tree.rootNode)\n        : { entries: [], syntaxErrors: [] };\n    const theirsAst =\n      theirsDoc.blocks.length > 0\n        ? extractSourceFile(theirsDoc.blocks[0].tree.rootNode)\n        : { entries: [], syntaxErrors: [] };\n\n    // Surface syntax errors as parse-error conflicts\n    const syntaxErrorConflicts: MergeConflict[] = [];\n    if (baseAst.syntaxErrors.length > 0) {\n      syntaxErrorConflicts.push({\n        type: \"parse-error\",\n        message: `Parse error in base: ${baseAst.syntaxErrors.map((e) => e.message || \"syntax error\").join(\", \")}`,\n        location: 0,\n        identity: { entryType: \"parse-error\" },\n        context: { errorMessage: \"base version has syntax errors\" },\n      });\n    }\n    if (oursAst.syntaxErrors.length > 0) {\n      syntaxErrorConflicts.push({\n        type: \"parse-error\",\n        message: `Parse error in ours: ${oursAst.syntaxErrors.map((e) => e.message || \"syntax error\").join(\", \")}`,\n        location: 0,\n        identity: { entryType: \"parse-error\" },\n        context: { errorMessage: \"ours version has syntax errors\" },\n      });\n    }\n    if (theirsAst.syntaxErrors.length > 0) {\n      syntaxErrorConflicts.push({\n        type: \"parse-error\",\n        message: `Parse error in theirs: ${theirsAst.syntaxErrors.map((e) => e.message || \"syntax error\").join(\", \")}`,\n        location: 0,\n        identity: { entryType: \"parse-error\" },\n        context: { errorMessage: \"theirs version has syntax errors\" },\n      });\n    }\n\n    if (syntaxErrorConflicts.length > 0) {\n      return {\n        success: false,\n        content: ours,\n        conflicts: syntaxErrorConflicts,\n        stats: {\n          totalEntries: 0,\n          oursOnly: 0,\n          theirsOnly: 0,\n          common: 0,\n          autoMerged: 0,\n          conflicts: syntaxErrorConflicts.length,\n        },\n      };\n    }\n\n    const matches = matchEntries(baseAst.entries, oursAst.entries, theirsAst.entries);\n\n    const conflicts = detectConflicts(matches, options);\n\n    const result = buildMergedResult(matches, conflicts, options);\n\n    return result;\n  } catch (error) {\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    return {\n      success: false,\n      content: ours,\n      conflicts: [\n        {\n          type: \"merge-error\",\n          message: `Merge failed: ${errorMessage}`,\n          location: 0,\n          identity: { entryType: \"error\" },\n          context: { errorMessage },\n        },\n      ],\n      stats: {\n        totalEntries: 0,\n        oursOnly: 0,\n        theirsOnly: 0,\n        common: 0,\n        autoMerged: 0,\n        conflicts: 1,\n      },\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDA,SAAgB,gBACd,MACA,MACA,QACA,UAAwB,EAAE,EACb;AACb,KAAI;EACF,MAAM,UAAU,cAAc,MAAM,EAAE,UAAU,SAAS,CAAC;EAC1D,MAAM,UAAU,cAAc,MAAM,EAAE,UAAU,SAAS,CAAC;EAC1D,MAAM,YAAY,cAAc,QAAQ,EAAE,UAAU,SAAS,CAAC;EAE9D,MAAM,UACJ,QAAQ,OAAO,SAAS,IACpB,kBAAkB,QAAQ,OAAO,GAAG,KAAK,SAAS,GAClD;GAAE,SAAS,EAAE;GAAE,cAAc,EAAE;GAAE;EACvC,MAAM,UACJ,QAAQ,OAAO,SAAS,IACpB,kBAAkB,QAAQ,OAAO,GAAG,KAAK,SAAS,GAClD;GAAE,SAAS,EAAE;GAAE,cAAc,EAAE;GAAE;EACvC,MAAM,YACJ,UAAU,OAAO,SAAS,IACtB,kBAAkB,UAAU,OAAO,GAAG,KAAK,SAAS,GACpD;GAAE,SAAS,EAAE;GAAE,cAAc,EAAE;GAAE;EAGvC,MAAMA,uBAAwC,EAAE;AAChD,MAAI,QAAQ,aAAa,SAAS,EAChC,sBAAqB,KAAK;GACxB,MAAM;GACN,SAAS,wBAAwB,QAAQ,aAAa,KAAK,MAAM,EAAE,WAAW,eAAe,CAAC,KAAK,KAAK;GACxG,UAAU;GACV,UAAU,EAAE,WAAW,eAAe;GACtC,SAAS,EAAE,cAAc,kCAAkC;GAC5D,CAAC;AAEJ,MAAI,QAAQ,aAAa,SAAS,EAChC,sBAAqB,KAAK;GACxB,MAAM;GACN,SAAS,wBAAwB,QAAQ,aAAa,KAAK,MAAM,EAAE,WAAW,eAAe,CAAC,KAAK,KAAK;GACxG,UAAU;GACV,UAAU,EAAE,WAAW,eAAe;GACtC,SAAS,EAAE,cAAc,kCAAkC;GAC5D,CAAC;AAEJ,MAAI,UAAU,aAAa,SAAS,EAClC,sBAAqB,KAAK;GACxB,MAAM;GACN,SAAS,0BAA0B,UAAU,aAAa,KAAK,MAAM,EAAE,WAAW,eAAe,CAAC,KAAK,KAAK;GAC5G,UAAU;GACV,UAAU,EAAE,WAAW,eAAe;GACtC,SAAS,EAAE,cAAc,oCAAoC;GAC9D,CAAC;AAGJ,MAAI,qBAAqB,SAAS,EAChC,QAAO;GACL,SAAS;GACT,SAAS;GACT,WAAW;GACX,OAAO;IACL,cAAc;IACd,UAAU;IACV,YAAY;IACZ,QAAQ;IACR,YAAY;IACZ,WAAW,qBAAqB;IACjC;GACF;EAGH,MAAM,UAAU,aAAa,QAAQ,SAAS,QAAQ,SAAS,UAAU,QAAQ;AAMjF,SAFe,kBAAkB,SAFf,gBAAgB,SAAS,QAAQ,EAEE,QAAQ;UAGtD,OAAO;EACd,MAAM,eAAe,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM;AAC3E,SAAO;GACL,SAAS;GACT,SAAS;GACT,WAAW,CACT;IACE,MAAM;IACN,SAAS,iBAAiB;IAC1B,UAAU;IACV,UAAU,EAAE,WAAW,SAAS;IAChC,SAAS,EAAE,cAAc;IAC1B,CACF;GACD,OAAO;IACL,cAAc;IACd,UAAU;IACV,YAAY;IACZ,QAAQ;IACR,YAAY;IACZ,WAAW;IACZ;GACF"}
+{"version":3,"file":"driver.js","names":["syntaxErrorConflicts: MergeConflict[]"],"sources":["../../src/merge/driver.ts"],"sourcesContent":["import { parseDocument } from \"../parser.node.js\";\nimport { extractSourceFile } from \"../ast/extract.js\";\nimport type { MergeResult } from \"./merge-result-builder.js\";\nimport type { MergeConflict, ConflictRule } from \"./conflict-detector.js\";\nimport { matchEntries } from \"./entry-matcher.js\";\nimport { detectConflicts } from \"./conflict-detector.js\";\nimport { buildMergedResult } from \"./merge-result-builder.js\";\n\n/**\n * Options for the merge driver\n */\nexport interface MergeOptions {\n  /**\n   * Conflict marker style\n   * - \"git\": Standard Git style (ours/theirs)\n   * - \"diff3\": Include base section\n   */\n  markerStyle?: \"git\" | \"diff3\";\n\n  /**\n   * Whether to include base in markers (diff3 style)\n   * Deprecated: Use markerStyle: \"diff3\" instead\n   */\n  showBase?: boolean;\n\n  /**\n   * Custom conflict detection rules\n   * Applied after default rules\n   */\n  conflictRules?: ConflictRule[];\n}\n\n/**\n * Perform three-way merge of thalo files\n *\n * This is the main entry point for the merge driver.\n * It parses all three versions, matches entries, detects conflicts,\n * and produces a merged result.\n *\n * This function is synchronous but requires the parser to be initialized first.\n * Call `await initParser()` from `@rejot-dev/thalo/node` before using this function.\n * Internally uses `parseDocument` which depends on the initialized parser.\n *\n * @param base - Base version content (common ancestor)\n * @param ours - Our version content (local changes)\n * @param theirs - Their version content (incoming changes)\n * @param options - Merge options\n * @returns MergeResult with merged content and conflict information\n * @throws Error if the parser has not been initialized\n *\n * @example\n * ```typescript\n * import { initParser } from \"@rejot-dev/thalo/node\";\n * import { mergeThaloFiles } from \"@rejot-dev/thalo\";\n *\n * // Initialize the parser first (required)\n * await initParser();\n *\n * const base = '2026-01-01T00:00Z define-entity lore \"Lore\"';\n * const ours = base + '\\n2026-01-02T00:00Z create lore \"My entry\" ^entry1';\n * const theirs = base + '\\n2026-01-03T00:00Z create lore \"Their entry\" ^entry2';\n *\n * const result = mergeThaloFiles(base, ours, theirs);\n * console.log(result.success); // true\n * console.log(result.content); // Merged content with both entries\n * ```\n */\nexport function mergeThaloFiles(\n  base: string,\n  ours: string,\n  theirs: string,\n  options: MergeOptions = {},\n): MergeResult {\n  try {\n    const baseDoc = parseDocument(base, { fileType: \"thalo\" });\n    const oursDoc = parseDocument(ours, { fileType: \"thalo\" });\n    const theirsDoc = parseDocument(theirs, { fileType: \"thalo\" });\n\n    const baseAst =\n      baseDoc.blocks.length > 0\n        ? extractSourceFile(baseDoc.blocks[0].tree.rootNode)\n        : { entries: [], syntaxErrors: [] };\n    const oursAst =\n      oursDoc.blocks.length > 0\n        ? extractSourceFile(oursDoc.blocks[0].tree.rootNode)\n        : { entries: [], syntaxErrors: [] };\n    const theirsAst =\n      theirsDoc.blocks.length > 0\n        ? extractSourceFile(theirsDoc.blocks[0].tree.rootNode)\n        : { entries: [], syntaxErrors: [] };\n\n    // Surface syntax errors as parse-error conflicts\n    const syntaxErrorConflicts: MergeConflict[] = [];\n    if (baseAst.syntaxErrors.length > 0) {\n      syntaxErrorConflicts.push({\n        type: \"parse-error\",\n        message: `Parse error in base: ${baseAst.syntaxErrors.map((e) => e.message || \"syntax error\").join(\", \")}`,\n        location: 0,\n        identity: { entryType: \"parse-error\" },\n        context: { errorMessage: \"base version has syntax errors\" },\n      });\n    }\n    if (oursAst.syntaxErrors.length > 0) {\n      syntaxErrorConflicts.push({\n        type: \"parse-error\",\n        message: `Parse error in ours: ${oursAst.syntaxErrors.map((e) => e.message || \"syntax error\").join(\", \")}`,\n        location: 0,\n        identity: { entryType: \"parse-error\" },\n        context: { errorMessage: \"ours version has syntax errors\" },\n      });\n    }\n    if (theirsAst.syntaxErrors.length > 0) {\n      syntaxErrorConflicts.push({\n        type: \"parse-error\",\n        message: `Parse error in theirs: ${theirsAst.syntaxErrors.map((e) => e.message || \"syntax error\").join(\", \")}`,\n        location: 0,\n        identity: { entryType: \"parse-error\" },\n        context: { errorMessage: \"theirs version has syntax errors\" },\n      });\n    }\n\n    if (syntaxErrorConflicts.length > 0) {\n      return {\n        success: false,\n        content: ours,\n        conflicts: syntaxErrorConflicts,\n        stats: {\n          totalEntries: 0,\n          oursOnly: 0,\n          theirsOnly: 0,\n          common: 0,\n          autoMerged: 0,\n          conflicts: syntaxErrorConflicts.length,\n        },\n      };\n    }\n\n    const matches = matchEntries(baseAst.entries, oursAst.entries, theirsAst.entries);\n\n    const conflicts = detectConflicts(matches, options);\n\n    const result = buildMergedResult(matches, conflicts, options);\n\n    return result;\n  } catch (error) {\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    return {\n      success: false,\n      content: ours,\n      conflicts: [\n        {\n          type: \"merge-error\",\n          message: `Merge failed: ${errorMessage}`,\n          location: 0,\n          identity: { entryType: \"error\" },\n          context: { errorMessage },\n        },\n      ],\n      stats: {\n        totalEntries: 0,\n        oursOnly: 0,\n        theirsOnly: 0,\n        common: 0,\n        autoMerged: 0,\n        conflicts: 1,\n      },\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEA,SAAgB,gBACd,MACA,MACA,QACA,UAAwB,EAAE,EACb;AACb,KAAI;EACF,MAAM,UAAU,cAAc,MAAM,EAAE,UAAU,SAAS,CAAC;EAC1D,MAAM,UAAU,cAAc,MAAM,EAAE,UAAU,SAAS,CAAC;EAC1D,MAAM,YAAY,cAAc,QAAQ,EAAE,UAAU,SAAS,CAAC;EAE9D,MAAM,UACJ,QAAQ,OAAO,SAAS,IACpB,kBAAkB,QAAQ,OAAO,GAAG,KAAK,SAAS,GAClD;GAAE,SAAS,EAAE;GAAE,cAAc,EAAE;GAAE;EACvC,MAAM,UACJ,QAAQ,OAAO,SAAS,IACpB,kBAAkB,QAAQ,OAAO,GAAG,KAAK,SAAS,GAClD;GAAE,SAAS,EAAE;GAAE,cAAc,EAAE;GAAE;EACvC,MAAM,YACJ,UAAU,OAAO,SAAS,IACtB,kBAAkB,UAAU,OAAO,GAAG,KAAK,SAAS,GACpD;GAAE,SAAS,EAAE;GAAE,cAAc,EAAE;GAAE;EAGvC,MAAMA,uBAAwC,EAAE;AAChD,MAAI,QAAQ,aAAa,SAAS,EAChC,sBAAqB,KAAK;GACxB,MAAM;GACN,SAAS,wBAAwB,QAAQ,aAAa,KAAK,MAAM,EAAE,WAAW,eAAe,CAAC,KAAK,KAAK;GACxG,UAAU;GACV,UAAU,EAAE,WAAW,eAAe;GACtC,SAAS,EAAE,cAAc,kCAAkC;GAC5D,CAAC;AAEJ,MAAI,QAAQ,aAAa,SAAS,EAChC,sBAAqB,KAAK;GACxB,MAAM;GACN,SAAS,wBAAwB,QAAQ,aAAa,KAAK,MAAM,EAAE,WAAW,eAAe,CAAC,KAAK,KAAK;GACxG,UAAU;GACV,UAAU,EAAE,WAAW,eAAe;GACtC,SAAS,EAAE,cAAc,kCAAkC;GAC5D,CAAC;AAEJ,MAAI,UAAU,aAAa,SAAS,EAClC,sBAAqB,KAAK;GACxB,MAAM;GACN,SAAS,0BAA0B,UAAU,aAAa,KAAK,MAAM,EAAE,WAAW,eAAe,CAAC,KAAK,KAAK;GAC5G,UAAU;GACV,UAAU,EAAE,WAAW,eAAe;GACtC,SAAS,EAAE,cAAc,oCAAoC;GAC9D,CAAC;AAGJ,MAAI,qBAAqB,SAAS,EAChC,QAAO;GACL,SAAS;GACT,SAAS;GACT,WAAW;GACX,OAAO;IACL,cAAc;IACd,UAAU;IACV,YAAY;IACZ,QAAQ;IACR,YAAY;IACZ,WAAW,qBAAqB;IACjC;GACF;EAGH,MAAM,UAAU,aAAa,QAAQ,SAAS,QAAQ,SAAS,UAAU,QAAQ;AAMjF,SAFe,kBAAkB,SAFf,gBAAgB,SAAS,QAAQ,EAEE,QAAQ;UAGtD,OAAO;EACd,MAAM,eAAe,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM;AAC3E,SAAO;GACL,SAAS;GACT,SAAS;GACT,WAAW,CACT;IACE,MAAM;IACN,SAAS,iBAAiB;IAC1B,UAAU;IACV,UAAU,EAAE,WAAW,SAAS;IAChC,SAAS,EAAE,cAAc;IAC1B,CACF;GACD,OAAO;IACL,cAAc;IACd,UAAU;IACV,YAAY;IACZ,QAAQ;IACR,YAAY;IACZ,WAAW;IACZ;GACF"}

package/dist/parser.node.d.ts

@@ -0,0 +1,66 @@
+import { FileType, GenericTree, ParseOptions, ParsedBlock as ParsedBlock$1, ParsedDocument as ParsedDocument$1, ThaloParser } from "./parser.shared.js";
+import { Workspace } from "./model/workspace.js";
+
+//#region src/parser.node.d.ts
+
+type ParsedBlock = ParsedBlock$1<GenericTree>;
+type ParsedDocument = ParsedDocument$1<GenericTree>;
+/**
+ * Check if the parser has been initialized.
+ */
+declare function isInitialized(): boolean;
+/**
+ * Check if using native bindings (vs WASM fallback).
+ * Only valid after `initParser()` has been called.
+ */
+declare function isUsingNative(): boolean;
+/**
+ * Initialize the parser, trying native first then falling back to WASM.
+ *
+ * This must be called (and awaited) once before using `createParser()` or
+ * `createWorkspace()`. Multiple calls are safe and will return immediately
+ * if already initialized.
+ *
+ * @returns Promise that resolves when parser is ready
+ * @throws Error if both native and WASM initialization fail
+ */
+declare function initParser(): Promise<void>;
+/**
+ * Create a ThaloParser instance.
+ *
+ * Note: `initParser()` must be called first.
+ *
+ * @throws Error if `initParser()` has not been called
+ */
+declare function createParser(): ThaloParser<GenericTree>;
+/**
+ * Create a Workspace with the initialized parser.
+ *
+ * Note: `initParser()` must be called first.
+ *
+ * @example
+ * ```typescript
+ * import { initParser, createWorkspace } from "@rejot-dev/thalo/node";
+ *
+ * await initParser();
+ * const workspace = createWorkspace();
+ * workspace.addDocument(source, { filename: "test.thalo" });
+ * ```
+ *
+ * @throws Error if `initParser()` has not been called
+ */
+declare function createWorkspace(): Workspace;
+/**
+ * Parse a document using the initialized parser.
+ *
+ * Note: `initParser()` must be called first.
+ *
+ * @param source - The source code to parse
+ * @param options - Parse options
+ * @returns A parsed document
+ * @throws Error if `initParser()` has not been called
+ */
+declare function parseDocument(source: string, options?: ParseOptions): ParsedDocument$1<GenericTree>;
+//#endregion
+export { type FileType, type ParseOptions, ParsedBlock, ParsedDocument, type ThaloParser, Workspace, createParser, createWorkspace, initParser, isInitialized, isUsingNative, parseDocument };
+//# sourceMappingURL=parser.node.d.ts.map

package/dist/parser.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.node.d.ts","names":[],"sources":["../src/parser.node.ts"],"sourcesContent":[],"mappings":";;;;;KAqCY,WAAA,GAAc,cAAmB;KACjC,cAAA,GAAiB,iBAAsB;;;;iBAenC,aAAA,CAAA;;;;;iBAQA,aAAA,CAAA;;;;;;;;;;;iBAcM,UAAA,CAAA,GAAc;;;;;;;;iBAkFpB,YAAA,CAAA,GAAgB,YAAY;;;;;;;;;;;;;;;;;iBAyB5B,eAAA,CAAA,GAAmB;;;;;;;;;;;iBAsBnB,aAAA,2BAEJ,eACT,iBAAsB"}

package/dist/parser.node.js

@@ -0,0 +1,118 @@
+import { createThaloParser } from "./parser.shared.js";
+import { Workspace } from "./model/workspace.js";
+
+//#region src/parser.node.ts
+let parserFactory = null;
+let usingNative = false;
+/**
+* Check if the parser has been initialized.
+*/
+function isInitialized() {
+	return parserFactory !== null;
+}
+/**
+* Check if using native bindings (vs WASM fallback).
+* Only valid after `initParser()` has been called.
+*/
+function isUsingNative() {
+	return usingNative;
+}
+/**
+* Initialize the parser, trying native first then falling back to WASM.
+*
+* This must be called (and awaited) once before using `createParser()` or
+* `createWorkspace()`. Multiple calls are safe and will return immediately
+* if already initialized.
+*
+* @returns Promise that resolves when parser is ready
+* @throws Error if both native and WASM initialization fail
+*/
+async function initParser() {
+	if (parserFactory) return;
+	try {
+		const { default: Parser } = await import("tree-sitter");
+		const { default: thalo } = await import("@rejot-dev/tree-sitter-thalo");
+		thalo.nodeTypeInfo ??= [];
+		new Parser().setLanguage(thalo);
+		parserFactory = () => {
+			const parser = new Parser();
+			parser.setLanguage(thalo);
+			return createThaloParser(parser);
+		};
+		usingNative = true;
+		return;
+	} catch {}
+	try {
+		const { Parser, Language } = await import("web-tree-sitter");
+		const { readFileSync } = await import("node:fs");
+		const { createRequire } = await import("node:module");
+		const require = createRequire(import.meta.url);
+		const treeSitterWasmPath = require.resolve("web-tree-sitter/tree-sitter.wasm");
+		const languageWasmPath = require.resolve("@rejot-dev/tree-sitter-thalo/tree-sitter-thalo.wasm");
+		const treeSitterWasm = readFileSync(treeSitterWasmPath);
+		const languageWasm = readFileSync(languageWasmPath);
+		await Parser.init({ wasmBinary: treeSitterWasm });
+		const language = await Language.load(languageWasm);
+		parserFactory = () => {
+			const parser = new Parser();
+			parser.setLanguage(language);
+			return createThaloParser(parser);
+		};
+		usingNative = false;
+		return;
+	} catch (wasmError) {
+		throw new Error(`Failed to initialize thalo parser. Native tree-sitter bindings are not available for your platform, and WASM fallback also failed: ${wasmError instanceof Error ? wasmError.message : wasmError}`);
+	}
+}
+let cachedParser = null;
+/**
+* Create a ThaloParser instance.
+*
+* Note: `initParser()` must be called first.
+*
+* @throws Error if `initParser()` has not been called
+*/
+function createParser() {
+	if (!parserFactory) throw new Error("Parser not initialized. Call `await initParser()` before using createParser().");
+	return parserFactory();
+}
+/**
+* Create a Workspace with the initialized parser.
+*
+* Note: `initParser()` must be called first.
+*
+* @example
+* ```typescript
+* import { initParser, createWorkspace } from "@rejot-dev/thalo/node";
+*
+* await initParser();
+* const workspace = createWorkspace();
+* workspace.addDocument(source, { filename: "test.thalo" });
+* ```
+*
+* @throws Error if `initParser()` has not been called
+*/
+function createWorkspace() {
+	if (!parserFactory) throw new Error("Parser not initialized. Call `await initParser()` before using createWorkspace().");
+	if (!cachedParser) cachedParser = parserFactory();
+	return new Workspace(cachedParser);
+}
+/**
+* Parse a document using the initialized parser.
+*
+* Note: `initParser()` must be called first.
+*
+* @param source - The source code to parse
+* @param options - Parse options
+* @returns A parsed document
+* @throws Error if `initParser()` has not been called
+*/
+function parseDocument(source, options) {
+	if (!parserFactory) throw new Error("Parser not initialized. Call `await initParser()` before using parseDocument().");
+	if (!cachedParser) cachedParser = parserFactory();
+	return cachedParser.parseDocument(source, options);
+}
+
+//#endregion
+export { Workspace, createParser, createWorkspace, initParser, isInitialized, isUsingNative, parseDocument };
+//# sourceMappingURL=parser.node.js.map

package/dist/parser.node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.node.js","names":["parserFactory: (() => ThaloParser<GenericTree>) | null","cachedParser: ThaloParser<GenericTree> | null"],"sources":["../src/parser.node.ts"],"sourcesContent":["/**\n * Node.js parser with automatic fallback from native to WASM.\n *\n * This module provides a unified API for Node.js environments that:\n * 1. Tries to use native tree-sitter bindings (fastest)\n * 2. Falls back to web-tree-sitter WASM if native bindings aren't available\n *\n * The fallback is transparent - callers don't need to know which implementation\n * is being used. The only requirement is that `initParser()` must be called\n * (and awaited) before using `createParser()` or `createWorkspace()`.\n *\n * @example\n * ```typescript\n * import { initParser, createWorkspace } from \"@rejot-dev/thalo/node\";\n *\n * // Initialize once at startup (required)\n * await initParser();\n *\n * // Then use synchronously\n * const workspace = createWorkspace();\n * workspace.addDocument(source, { filename: \"test.thalo\" });\n * ```\n */\n\nimport {\n  createThaloParser,\n  type ThaloParser,\n  type ParsedBlock as GenericParsedBlock,\n  type ParsedDocument as GenericParsedDocument,\n  type FileType,\n  type ParseOptions,\n  type GenericTree,\n} from \"./parser.shared.js\";\nimport type { Language as NativeLanguage } from \"tree-sitter\";\nimport { Workspace } from \"./model/workspace.js\";\n\n// Re-export shared types\nexport type ParsedBlock = GenericParsedBlock<GenericTree>;\nexport type ParsedDocument = GenericParsedDocument<GenericTree>;\nexport type { FileType, ParseOptions, ThaloParser };\n\n// Re-export Workspace for convenience\nexport { Workspace } from \"./model/workspace.js\";\n\n// Parser factory function - set after initialization\nlet parserFactory: (() => ThaloParser<GenericTree>) | null = null;\n\n// Track which implementation is being used\nlet usingNative = false;\n\n/**\n * Check if the parser has been initialized.\n */\nexport function isInitialized(): boolean {\n  return parserFactory !== null;\n}\n\n/**\n * Check if using native bindings (vs WASM fallback).\n * Only valid after `initParser()` has been called.\n */\nexport function isUsingNative(): boolean {\n  return usingNative;\n}\n\n/**\n * Initialize the parser, trying native first then falling back to WASM.\n *\n * This must be called (and awaited) once before using `createParser()` or\n * `createWorkspace()`. Multiple calls are safe and will return immediately\n * if already initialized.\n *\n * @returns Promise that resolves when parser is ready\n * @throws Error if both native and WASM initialization fail\n */\nexport async function initParser(): Promise<void> {\n  // Already initialized\n  if (parserFactory) {\n    return;\n  }\n\n  // Try native first\n  try {\n    const { default: Parser } = await import(\"tree-sitter\");\n    const { default: thalo } = await import(\"@rejot-dev/tree-sitter-thalo\");\n\n    // Ensure nodeTypeInfo is an array\n    thalo.nodeTypeInfo ??= [];\n\n    // Test that we can actually create a parser (this will fail if native bindings are broken)\n    const testParser = new Parser();\n    testParser.setLanguage(thalo as unknown as NativeLanguage);\n\n    // Native works! Set up the factory\n    parserFactory = () => {\n      const parser = new Parser();\n      parser.setLanguage(thalo as unknown as NativeLanguage);\n      return createThaloParser(parser);\n    };\n    usingNative = true;\n    return;\n  } catch {\n    // Native failed, try WASM fallback\n  }\n\n  // Fall back to WASM\n  try {\n    const { Parser, Language } = await import(\"web-tree-sitter\");\n\n    // Dynamically import Node.js APIs for WASM file loading\n    const { readFileSync } = await import(\"node:fs\");\n    const { createRequire } = await import(\"node:module\");\n    const require = createRequire(import.meta.url);\n\n    // Resolve WASM file paths from installed dependencies\n    const treeSitterWasmPath = require.resolve(\"web-tree-sitter/tree-sitter.wasm\");\n    const languageWasmPath = require.resolve(\"@rejot-dev/tree-sitter-thalo/tree-sitter-thalo.wasm\");\n\n    // Load WASM files\n    const treeSitterWasm = readFileSync(treeSitterWasmPath);\n    const languageWasm = readFileSync(languageWasmPath);\n\n    // Initialize web-tree-sitter\n    await Parser.init({\n      wasmBinary: treeSitterWasm,\n    });\n\n    // Load the thalo language\n    const language = await Language.load(languageWasm);\n\n    // WASM works! Set up the factory\n    parserFactory = () => {\n      const parser = new Parser();\n      parser.setLanguage(language);\n      return createThaloParser(parser);\n    };\n    usingNative = false;\n    return;\n  } catch (wasmError) {\n    throw new Error(\n      `Failed to initialize thalo parser. ` +\n        `Native tree-sitter bindings are not available for your platform, ` +\n        `and WASM fallback also failed: ${wasmError instanceof Error ? wasmError.message : wasmError}`,\n    );\n  }\n}\n\n// Cached parser instance for createWorkspace\nlet cachedParser: ThaloParser<GenericTree> | null = null;\n\n/**\n * Create a ThaloParser instance.\n *\n * Note: `initParser()` must be called first.\n *\n * @throws Error if `initParser()` has not been called\n */\nexport function createParser(): ThaloParser<GenericTree> {\n  if (!parserFactory) {\n    throw new Error(\n      \"Parser not initialized. Call `await initParser()` before using createParser().\",\n    );\n  }\n  return parserFactory();\n}\n\n/**\n * Create a Workspace with the initialized parser.\n *\n * Note: `initParser()` must be called first.\n *\n * @example\n * ```typescript\n * import { initParser, createWorkspace } from \"@rejot-dev/thalo/node\";\n *\n * await initParser();\n * const workspace = createWorkspace();\n * workspace.addDocument(source, { filename: \"test.thalo\" });\n * ```\n *\n * @throws Error if `initParser()` has not been called\n */\nexport function createWorkspace(): Workspace {\n  if (!parserFactory) {\n    throw new Error(\n      \"Parser not initialized. Call `await initParser()` before using createWorkspace().\",\n    );\n  }\n  if (!cachedParser) {\n    cachedParser = parserFactory();\n  }\n  return new Workspace(cachedParser);\n}\n\n/**\n * Parse a document using the initialized parser.\n *\n * Note: `initParser()` must be called first.\n *\n * @param source - The source code to parse\n * @param options - Parse options\n * @returns A parsed document\n * @throws Error if `initParser()` has not been called\n */\nexport function parseDocument(\n  source: string,\n  options?: ParseOptions,\n): GenericParsedDocument<GenericTree> {\n  if (!parserFactory) {\n    throw new Error(\n      \"Parser not initialized. Call `await initParser()` before using parseDocument().\",\n    );\n  }\n  if (!cachedParser) {\n    cachedParser = parserFactory();\n  }\n  return cachedParser.parseDocument(source, options);\n}\n"],"mappings":";;;;AA6CA,IAAIA,gBAAyD;AAG7D,IAAI,cAAc;;;;AAKlB,SAAgB,gBAAyB;AACvC,QAAO,kBAAkB;;;;;;AAO3B,SAAgB,gBAAyB;AACvC,QAAO;;;;;;;;;;;;AAaT,eAAsB,aAA4B;AAEhD,KAAI,cACF;AAIF,KAAI;EACF,MAAM,EAAE,SAAS,WAAW,MAAM,OAAO;EACzC,MAAM,EAAE,SAAS,UAAU,MAAM,OAAO;AAGxC,QAAM,iBAAiB,EAAE;AAIzB,EADmB,IAAI,QAAQ,CACpB,YAAY,MAAmC;AAG1D,wBAAsB;GACpB,MAAM,SAAS,IAAI,QAAQ;AAC3B,UAAO,YAAY,MAAmC;AACtD,UAAO,kBAAkB,OAAO;;AAElC,gBAAc;AACd;SACM;AAKR,KAAI;EACF,MAAM,EAAE,QAAQ,aAAa,MAAM,OAAO;EAG1C,MAAM,EAAE,iBAAiB,MAAM,OAAO;EACtC,MAAM,EAAE,kBAAkB,MAAM,OAAO;EACvC,MAAM,UAAU,cAAc,OAAO,KAAK,IAAI;EAG9C,MAAM,qBAAqB,QAAQ,QAAQ,mCAAmC;EAC9E,MAAM,mBAAmB,QAAQ,QAAQ,sDAAsD;EAG/F,MAAM,iBAAiB,aAAa,mBAAmB;EACvD,MAAM,eAAe,aAAa,iBAAiB;AAGnD,QAAM,OAAO,KAAK,EAChB,YAAY,gBACb,CAAC;EAGF,MAAM,WAAW,MAAM,SAAS,KAAK,aAAa;AAGlD,wBAAsB;GACpB,MAAM,SAAS,IAAI,QAAQ;AAC3B,UAAO,YAAY,SAAS;AAC5B,UAAO,kBAAkB,OAAO;;AAElC,gBAAc;AACd;UACO,WAAW;AAClB,QAAM,IAAI,MACR,sIAEoC,qBAAqB,QAAQ,UAAU,UAAU,YACtF;;;AAKL,IAAIC,eAAgD;;;;;;;;AASpD,SAAgB,eAAyC;AACvD,KAAI,CAAC,cACH,OAAM,IAAI,MACR,iFACD;AAEH,QAAO,eAAe;;;;;;;;;;;;;;;;;;AAmBxB,SAAgB,kBAA6B;AAC3C,KAAI,CAAC,cACH,OAAM,IAAI,MACR,oFACD;AAEH,KAAI,CAAC,aACH,gBAAe,eAAe;AAEhC,QAAO,IAAI,UAAU,aAAa;;;;;;;;;;;;AAapC,SAAgB,cACd,QACA,SACoC;AACpC,KAAI,CAAC,cACH,OAAM,IAAI,MACR,kFACD;AAEH,KAAI,CAAC,aACH,gBAAe,eAAe;AAEhC,QAAO,aAAa,cAAc,QAAQ,QAAQ"}

package/dist/services/change-tracker/git-tracker.js

@@ -1,10 +1,10 @@
 import { entryMatchesQuery } from "../query.js";
 import { UncommittedChangesError } from "./change-tracker.js";
 import { extractSourceFile } from "../../ast/extract.js";
-import { parseDocument } from "../../parser.js";
 import { getEntryIdentity, serializeIdentity } from "../../merge/entry-matcher.js";
 import { entriesEqual } from "../../merge/entry-merger.js";
 import { commitExists, detectGitContext, getBlameCommitsForLineRange, getBlameIgnoreRevs, getCurrentCommit, getFileAtCommit, getFilesChangedSince, getUncommittedFiles, isCommitAncestorOf } from "../../git/git.js";
+import { parseDocument } from "../../parser.js";
 
 //#region src/services/change-tracker/git-tracker.ts
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rejot-dev/thalo",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "type": "module",
   "repository": {
     "type": "git",
@@ -29,6 +29,11 @@
       "types": "./dist/parser.web.d.ts",
       "default": "./dist/parser.web.js"
     },
+    "./node": {
+      "development": "./src/parser.node.ts",
+      "types": "./dist/parser.node.d.ts",
+      "default": "./dist/parser.node.js"
+    },
     "./services/semantic-tokens": {
       "development": "./src/services/semantic-tokens.ts",
       "types": "./dist/services/semantic-tokens.d.ts",
@@ -88,12 +93,17 @@
       "development": "./src/files.ts",
       "types": "./dist/files.d.ts",
       "default": "./dist/files.js"
+    },
+    "./api": {
+      "development": "./src/api.ts",
+      "types": "./dist/api.d.ts",
+      "default": "./dist/api.js"
     }
   },
   "main": "./dist/mod.js",
   "types": "./dist/mod.d.ts",
   "dependencies": {
-    "@rejot-dev/tree-sitter-thalo": "0.1.0"
+    "@rejot-dev/tree-sitter-thalo": "0.2.1"
   },
   "peerDependencies": {
     "tree-sitter": "^0.25.0",