@rejot-dev/thalo 0.0.0

package/dist/parser.native.d.ts

@@ -0,0 +1,51 @@
+import { FileType, ParseOptions, ParsedBlock as ParsedBlock$1, ParsedDocument as ParsedDocument$1, ThaloParser } from "./parser.shared.js";
+import { Workspace } from "./model/workspace.js";
+import { Tree } from "tree-sitter";
+
+//#region src/parser.native.d.ts
+
+type ParsedBlock = ParsedBlock$1<Tree>;
+type ParsedDocument = ParsedDocument$1<Tree>;
+/**
+ * Create a native ThaloParser instance.
+ *
+ * This creates a new tree-sitter Parser with the thalo language loaded.
+ * Each call creates a new parser instance.
+ *
+ * @example
+ * ```typescript
+ * import { createParser } from "@rejot-dev/thalo/native";
+ *
+ * const parser = createParser();
+ * const tree = parser.parse(source);
+ * const doc = parser.parseDocument(source, { fileType: "thalo" });
+ * ```
+ */
+declare function createParser(): ThaloParser<Tree>;
+/**
+ * Create a Workspace with the native (Node.js) parser.
+ *
+ * This is a convenience function for Node.js environments that don't need
+ * to customize the parser. For browser environments, use the Workspace
+ * constructor directly with a web parser.
+ *
+ * @example
+ * ```typescript
+ * import { createWorkspace } from "@rejot-dev/thalo/native";
+ *
+ * const workspace = createWorkspace();
+ * workspace.addDocument(source, { filename: "test.thalo" });
+ * ```
+ */
+declare function createWorkspace(): Workspace;
+/**
+ * Get the singleton parser (creating it if needed) and parse a document.
+ *
+ * @param source - The source code to parse
+ * @param options - Parse options
+ * @returns A parsed document
+ */
+declare function parseDocument(source: string, options?: ParseOptions): ParsedDocument$1<Tree>;
+//#endregion
+export { type FileType, type ParseOptions, ParsedBlock, ParsedDocument, type ThaloParser, Workspace, createParser, createWorkspace, parseDocument };
+//# sourceMappingURL=parser.native.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parser.native.d.ts","names":[],"sources":["../src/parser.native.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBY,KADA,WAAA,GAAc,aACG,CADgB,IAChB,CAAA;AAwBb,KAxBJ,cAAA,GAAiB,gBAwBc,CAxBQ,IAwBR,CAAA;;;;;;;;;;;;;;;;iBAA3B,YAAA,CAAA,GAAgB,YAAY;;;;;;;;;;;;;;;;iBAyB5B,eAAA,CAAA,GAAmB;;;;;;;;iBAcnB,aAAA,2BAAwC,eAAe,iBAAsB"}

package/dist/parser.native.js

@@ -0,0 +1,62 @@
+import { createThaloParser } from "./parser.shared.js";
+import { Workspace } from "./model/workspace.js";
+import Parser from "tree-sitter";
+import thalo from "@rejot-dev/tree-sitter-thalo";
+
+//#region src/parser.native.ts
+let cachedParser = null;
+/**
+* Create a native ThaloParser instance.
+*
+* This creates a new tree-sitter Parser with the thalo language loaded.
+* Each call creates a new parser instance.
+*
+* @example
+* ```typescript
+* import { createParser } from "@rejot-dev/thalo/native";
+*
+* const parser = createParser();
+* const tree = parser.parse(source);
+* const doc = parser.parseDocument(source, { fileType: "thalo" });
+* ```
+*/
+function createParser() {
+	thalo.nodeTypeInfo ??= [];
+	const tsParser = new Parser();
+	tsParser.setLanguage(thalo);
+	return createThaloParser(tsParser);
+}
+/**
+* Create a Workspace with the native (Node.js) parser.
+*
+* This is a convenience function for Node.js environments that don't need
+* to customize the parser. For browser environments, use the Workspace
+* constructor directly with a web parser.
+*
+* @example
+* ```typescript
+* import { createWorkspace } from "@rejot-dev/thalo/native";
+*
+* const workspace = createWorkspace();
+* workspace.addDocument(source, { filename: "test.thalo" });
+* ```
+*/
+function createWorkspace() {
+	if (!cachedParser) cachedParser = createParser();
+	return new Workspace(cachedParser);
+}
+/**
+* Get the singleton parser (creating it if needed) and parse a document.
+*
+* @param source - The source code to parse
+* @param options - Parse options
+* @returns A parsed document
+*/
+function parseDocument(source, options) {
+	if (!cachedParser) cachedParser = createParser();
+	return cachedParser.parseDocument(source, options);
+}
+
+//#endregion
+export { Workspace, createParser, createWorkspace, parseDocument };
+//# sourceMappingURL=parser.native.js.map

package/dist/parser.native.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.native.js","names":["cachedParser: ThaloParser<Tree> | null"],"sources":["../src/parser.native.ts"],"sourcesContent":["/**\n * Native (Node.js) parser implementation using tree-sitter native bindings.\n */\n\nimport Parser, { type Language, type Tree } from \"tree-sitter\";\nimport thalo from \"@rejot-dev/tree-sitter-thalo\";\nimport {\n  createThaloParser,\n  type ThaloParser,\n  type ParsedBlock as GenericParsedBlock,\n  type ParsedDocument as GenericParsedDocument,\n  type FileType,\n  type ParseOptions,\n} from \"./parser.shared.js\";\nimport { Workspace } from \"./model/workspace.js\";\n\n// Re-export shared types specialized to native Tree type\nexport type ParsedBlock = GenericParsedBlock<Tree>;\nexport type ParsedDocument = GenericParsedDocument<Tree>;\nexport type { FileType, ParseOptions, ThaloParser };\n\n// Re-export Workspace for convenience\nexport { Workspace } from \"./model/workspace.js\";\n\n// Cached parser instance for createWorkspace\nlet cachedParser: ThaloParser<Tree> | null = null;\n\n/**\n * Create a native ThaloParser instance.\n *\n * This creates a new tree-sitter Parser with the thalo language loaded.\n * Each call creates a new parser instance.\n *\n * @example\n * ```typescript\n * import { createParser } from \"@rejot-dev/thalo/native\";\n *\n * const parser = createParser();\n * const tree = parser.parse(source);\n * const doc = parser.parseDocument(source, { fileType: \"thalo\" });\n * ```\n */\nexport function createParser(): ThaloParser<Tree> {\n  // Ensure nodeTypeInfo is an array (may be undefined if JSON import fails in some environments)\n  thalo.nodeTypeInfo ??= [];\n\n  const tsParser = new Parser();\n  tsParser.setLanguage(thalo as unknown as Language);\n\n  return createThaloParser(tsParser);\n}\n\n/**\n * Create a Workspace with the native (Node.js) parser.\n *\n * This is a convenience function for Node.js environments that don't need\n * to customize the parser. For browser environments, use the Workspace\n * constructor directly with a web parser.\n *\n * @example\n * ```typescript\n * import { createWorkspace } from \"@rejot-dev/thalo/native\";\n *\n * const workspace = createWorkspace();\n * workspace.addDocument(source, { filename: \"test.thalo\" });\n * ```\n */\nexport function createWorkspace(): Workspace {\n  if (!cachedParser) {\n    cachedParser = createParser();\n  }\n  return new Workspace(cachedParser);\n}\n\n/**\n * Get the singleton parser (creating it if needed) and parse a document.\n *\n * @param source - The source code to parse\n * @param options - Parse options\n * @returns A parsed document\n */\nexport function parseDocument(source: string, options?: ParseOptions): GenericParsedDocument<Tree> {\n  if (!cachedParser) {\n    cachedParser = createParser();\n  }\n  return cachedParser.parseDocument(source, options);\n}\n"],"mappings":";;;;;;AAyBA,IAAIA,eAAyC;;;;;;;;;;;;;;;;AAiB7C,SAAgB,eAAkC;AAEhD,OAAM,iBAAiB,EAAE;CAEzB,MAAM,WAAW,IAAI,QAAQ;AAC7B,UAAS,YAAY,MAA6B;AAElD,QAAO,kBAAkB,SAAS;;;;;;;;;;;;;;;;;AAkBpC,SAAgB,kBAA6B;AAC3C,KAAI,CAAC,aACH,gBAAe,cAAc;AAE/B,QAAO,IAAI,UAAU,aAAa;;;;;;;;;AAUpC,SAAgB,cAAc,QAAgB,SAAqD;AACjG,KAAI,CAAC,aACH,gBAAe,cAAc;AAE/B,QAAO,aAAa,cAAc,QAAQ,QAAQ"}

package/dist/parser.shared.d.ts

@@ -0,0 +1,99 @@
+import { SyntaxNode } from "./ast/ast-types.js";
+import { SourceMap } from "./source-map.js";
+
+//#region src/parser.shared.d.ts
+
+/**
+ * Edit parameters for incremental parsing.
+ */
+interface TreeEdit {
+  startIndex: number;
+  oldEndIndex: number;
+  newEndIndex: number;
+  startPosition: {
+    row: number;
+    column: number;
+  };
+  oldEndPosition: {
+    row: number;
+    column: number;
+  };
+  newEndPosition: {
+    row: number;
+    column: number;
+  };
+}
+/**
+ * A generic tree interface that both tree-sitter and web-tree-sitter satisfy.
+ *
+ * Note: Both `Tree` (from tree-sitter) and `Tree` (from web-tree-sitter) have this shape.
+ * The main difference is that web-tree-sitter's SyntaxNode is called "Node", but the
+ * interface is compatible.
+ *
+ * This is a minimal interface that only specifies the properties we actually use.
+ * The actual Tree types have many more properties (language, copy, delete, etc.)
+ * but we don't constrain those to keep the interface flexible.
+ */
+interface GenericTree {
+  readonly rootNode: SyntaxNode;
+  /** Edit the tree for incremental parsing */
+  edit(edit: TreeEdit): void;
+}
+/**
+ * A parsed thalo block with its source, source map for position translation, and parse tree.
+ */
+interface ParsedBlock<T extends GenericTree = GenericTree> {
+  /** The thalo source code */
+  source: string;
+  /** Source map for translating block-relative positions to file-absolute positions */
+  sourceMap: SourceMap;
+  /** The parsed tree-sitter tree */
+  tree: T;
+}
+/**
+ * A parsed document containing one or more thalo blocks.
+ */
+interface ParsedDocument<T extends GenericTree = GenericTree> {
+  /** The parsed thalo blocks */
+  blocks: ParsedBlock<T>[];
+}
+/**
+ * File type for parsing
+ */
+type FileType = "thalo" | "markdown";
+/**
+ * Options for parseDocument
+ */
+interface ParseOptions {
+  /** The file type. If not provided, uses heuristics based on filename or content. */
+  fileType?: FileType;
+  /** Optional filename (used for heuristics if fileType is not provided) */
+  filename?: string;
+}
+/**
+ * The ThaloParser interface - a configured parser instance that can parse thalo source.
+ */
+interface ThaloParser<T extends GenericTree = GenericTree> {
+  /**
+   * Parse a thalo source string into a tree-sitter Tree.
+   */
+  parse(source: string): T;
+  /**
+   * Parse a thalo source string with optional incremental parsing.
+   *
+   * When an oldTree is provided, tree-sitter can reuse unchanged parts of the
+   * parse tree, making parsing much faster for small edits.
+   *
+   * Note: Before calling this with an oldTree, you must call oldTree.edit()
+   * to inform tree-sitter about the changes made to the source.
+   */
+  parseIncremental(source: string, oldTree?: T): T;
+  /**
+   * Parse a document, automatically detecting if it's a .thalo file or markdown
+   * with embedded thalo blocks.
+   */
+  parseDocument(source: string, options?: ParseOptions): ParsedDocument<T>;
+}
+//#endregion
+export { FileType, GenericTree, ParseOptions, ParsedBlock, ParsedDocument, ThaloParser };
+//# sourceMappingURL=parser.shared.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parser.shared.d.ts","names":[],"sources":["../src/parser.shared.ts"],"sourcesContent":[],"mappings":";;;;;AA+CA;;;AAIa,UAxCI,QAAA,CAwCJ;EAEL,UAAA,EAAA,MAAA;EAAC,WAAA,EAAA,MAAA;EAMQ,WAAA,EAAA,MAAc;EAAW,aAAA,EAAA;IAAc,GAAA,EAAA,MAAA;IAElC,MAAA,EAAA,MAAA;EAAZ,CAAA;EAAW,cAAA,EAAA;IAMT,GAAA,EAAA,MAAQ;IAKH,MAAA,EAAA,MAAY;EAgCZ,CAAA;EAAsB,cAAA,EAAA;IAAc,GAAA,EAAA,MAAA;IAI5B,MAAA,EAAA,MAAA;EAWoB,CAAA;;;;;;;;;;;;;UAxF5B,WAAA;qBACI;;aAER;;;;;UAaI,sBAAsB,cAAc;;;;aAIxC;;QAEL;;;;;UAMS,yBAAyB,cAAc;;UAE9C,YAAY;;;;;KAMV,QAAA;;;;UAKK,YAAA;;aAEJ;;;;;;;UA8BI,sBAAsB,cAAc;;;;yBAI5B;;;;;;;;;;6CAWoB,IAAI;;;;;0CAMP,eAAe,eAAe"}

package/dist/parser.shared.js

@@ -0,0 +1,124 @@
+import { createSourceMap, identitySourceMap } from "./source-map.js";
+
+//#region src/parser.shared.ts
+/**
+* Regex to match fenced thalo code blocks in markdown.
+* Captures the content between ```thalo and ```
+*/
+const THALO_FENCE_REGEX = /^```thalo\s*\n([\s\S]*?)^```/gm;
+/**
+* Detect file type from filename extension.
+*
+* @param filename - The filename to check
+* @returns The detected file type ("thalo" or "markdown"), or undefined if unknown
+*/
+function detectFileType(filename) {
+	if (filename.endsWith(".thalo")) return "thalo";
+	if (filename.endsWith(".md")) return "markdown";
+}
+/**
+* Create a ThaloParser from a generic tree-sitter parser instance.
+*
+* @param tsParser - A tree-sitter or web-tree-sitter Parser instance with the thalo language loaded
+* @returns A ThaloParser instance
+*/
+function createThaloParser(tsParser) {
+	/**
+	* Parse a thalo source string into a tree-sitter Tree.
+	*
+	* @param source - The thalo source code to parse
+	* @returns The parsed tree-sitter Tree
+	* @throws Error if parsing fails
+	*/
+	function parse(source) {
+		const tree = tsParser.parse(source);
+		if (!tree) throw new Error("Failed to parse source");
+		return tree;
+	}
+	/**
+	* Parse a thalo source string with optional incremental parsing.
+	*
+	* @param source - The thalo source code to parse
+	* @param oldTree - Optional previous tree for incremental parsing
+	* @returns The parsed tree-sitter Tree
+	* @throws Error if parsing fails
+	*/
+	function parseIncremental(source, oldTree) {
+		const tree = tsParser.parse(source, oldTree);
+		if (!tree) throw new Error("Failed to parse source");
+		return tree;
+	}
+	/**
+	* Extract thalo code blocks from markdown source.
+	*
+	* Searches for fenced code blocks marked with ```thalo and extracts
+	* their content, creating a ParsedDocument with one ParsedBlock per
+	* code block found.
+	*
+	* @param source - The markdown source containing thalo code blocks
+	* @returns A ParsedDocument containing the extracted thalo blocks
+	*/
+	function extractThaloBlocks(source) {
+		const blocks = [];
+		let match;
+		while ((match = THALO_FENCE_REGEX.exec(source)) !== null) {
+			const content = match[1];
+			const sourceMap = createSourceMap(source, match.index + match[0].indexOf(content), content);
+			blocks.push({
+				source: content,
+				sourceMap,
+				tree: parse(content)
+			});
+		}
+		THALO_FENCE_REGEX.lastIndex = 0;
+		return { blocks };
+	}
+	/**
+	* Parse a pure thalo document (not markdown).
+	*
+	* Creates a ParsedDocument with a single block containing the entire
+	* source as a thalo file.
+	*
+	* @param source - The thalo source code
+	* @returns A ParsedDocument with a single block
+	*/
+	function parseThaloDocument(source) {
+		return { blocks: [{
+			source,
+			sourceMap: identitySourceMap(),
+			tree: parse(source)
+		}] };
+	}
+	/**
+	* Parse a document, automatically detecting if it's a .thalo file or markdown
+	* with embedded thalo blocks.
+	*
+	* Uses fileType option, filename-based heuristics, or content-based heuristics
+	* to determine how to parse the source.
+	*
+	* @param source - The source code to parse
+	* @param options - Parse options including fileType and filename
+	* @returns A ParsedDocument containing one or more parsed blocks
+	*/
+	function parseDocument(source, options = {}) {
+		const { fileType, filename } = options;
+		if (fileType === "thalo") return parseThaloDocument(source);
+		if (fileType === "markdown") return extractThaloBlocks(source);
+		if (filename) {
+			const detected = detectFileType(filename);
+			if (detected === "thalo") return parseThaloDocument(source);
+			if (detected === "markdown") return extractThaloBlocks(source);
+		}
+		if (source.includes("```thalo")) return extractThaloBlocks(source);
+		return parseThaloDocument(source);
+	}
+	return {
+		parse,
+		parseIncremental,
+		parseDocument
+	};
+}
+
+//#endregion
+export { createThaloParser };
+//# sourceMappingURL=parser.shared.js.map

package/dist/parser.shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.shared.js","names":["blocks: ParsedBlock<T>[]","match: RegExpExecArray | null"],"sources":["../src/parser.shared.ts"],"sourcesContent":["/**\n * Shared parser logic used by both native (Node.js) and web (WASM) implementations.\n * This module is platform-agnostic and works with any tree-sitter-like parser.\n */\n\nimport { createSourceMap, identitySourceMap, type SourceMap } from \"./source-map.js\";\nimport type { SyntaxNode } from \"./ast/ast-types.js\";\n\n/**\n * Edit parameters for incremental parsing.\n */\nexport interface TreeEdit {\n  startIndex: number;\n  oldEndIndex: number;\n  newEndIndex: number;\n  startPosition: { row: number; column: number };\n  oldEndPosition: { row: number; column: number };\n  newEndPosition: { row: number; column: number };\n}\n\n/**\n * A generic tree interface that both tree-sitter and web-tree-sitter satisfy.\n *\n * Note: Both `Tree` (from tree-sitter) and `Tree` (from web-tree-sitter) have this shape.\n * The main difference is that web-tree-sitter's SyntaxNode is called \"Node\", but the\n * interface is compatible.\n *\n * This is a minimal interface that only specifies the properties we actually use.\n * The actual Tree types have many more properties (language, copy, delete, etc.)\n * but we don't constrain those to keep the interface flexible.\n */\nexport interface GenericTree {\n  readonly rootNode: SyntaxNode;\n  /** Edit the tree for incremental parsing */\n  edit(edit: TreeEdit): void;\n}\n\n/**\n * A generic parser interface that both tree-sitter and web-tree-sitter satisfy.\n */\nexport interface GenericParser<T extends GenericTree> {\n  parse(source: string, oldTree?: T | null): T | null;\n}\n\n/**\n * A parsed thalo block with its source, source map for position translation, and parse tree.\n */\nexport interface ParsedBlock<T extends GenericTree = GenericTree> {\n  /** The thalo source code */\n  source: string;\n  /** Source map for translating block-relative positions to file-absolute positions */\n  sourceMap: SourceMap;\n  /** The parsed tree-sitter tree */\n  tree: T;\n}\n\n/**\n * A parsed document containing one or more thalo blocks.\n */\nexport interface ParsedDocument<T extends GenericTree = GenericTree> {\n  /** The parsed thalo blocks */\n  blocks: ParsedBlock<T>[];\n}\n\n/**\n * File type for parsing\n */\nexport type FileType = \"thalo\" | \"markdown\";\n\n/**\n * Options for parseDocument\n */\nexport interface ParseOptions {\n  /** The file type. If not provided, uses heuristics based on filename or content. */\n  fileType?: FileType;\n  /** Optional filename (used for heuristics if fileType is not provided) */\n  filename?: string;\n}\n\n/**\n * Regex to match fenced thalo code blocks in markdown.\n * Captures the content between ```thalo and ```\n */\nconst THALO_FENCE_REGEX = /^```thalo\\s*\\n([\\s\\S]*?)^```/gm;\n\n/**\n * Detect file type from filename extension.\n *\n * @param filename - The filename to check\n * @returns The detected file type (\"thalo\" or \"markdown\"), or undefined if unknown\n */\nexport function detectFileType(filename: string): FileType | undefined {\n  if (filename.endsWith(\".thalo\")) {\n    return \"thalo\";\n  }\n  if (filename.endsWith(\".md\")) {\n    return \"markdown\";\n  }\n  return undefined;\n}\n\n/**\n * The ThaloParser interface - a configured parser instance that can parse thalo source.\n */\nexport interface ThaloParser<T extends GenericTree = GenericTree> {\n  /**\n   * Parse a thalo source string into a tree-sitter Tree.\n   */\n  parse(source: string): T;\n\n  /**\n   * Parse a thalo source string with optional incremental parsing.\n   *\n   * When an oldTree is provided, tree-sitter can reuse unchanged parts of the\n   * parse tree, making parsing much faster for small edits.\n   *\n   * Note: Before calling this with an oldTree, you must call oldTree.edit()\n   * to inform tree-sitter about the changes made to the source.\n   */\n  parseIncremental(source: string, oldTree?: T): T;\n\n  /**\n   * Parse a document, automatically detecting if it's a .thalo file or markdown\n   * with embedded thalo blocks.\n   */\n  parseDocument(source: string, options?: ParseOptions): ParsedDocument<T>;\n}\n\n/**\n * Create a ThaloParser from a generic tree-sitter parser instance.\n *\n * @param tsParser - A tree-sitter or web-tree-sitter Parser instance with the thalo language loaded\n * @returns A ThaloParser instance\n */\nexport function createThaloParser<T extends GenericTree>(\n  tsParser: GenericParser<T>,\n): ThaloParser<T> {\n  /**\n   * Parse a thalo source string into a tree-sitter Tree.\n   *\n   * @param source - The thalo source code to parse\n   * @returns The parsed tree-sitter Tree\n   * @throws Error if parsing fails\n   */\n  function parse(source: string): T {\n    const tree = tsParser.parse(source);\n    if (!tree) {\n      throw new Error(\"Failed to parse source\");\n    }\n    return tree;\n  }\n\n  /**\n   * Parse a thalo source string with optional incremental parsing.\n   *\n   * @param source - The thalo source code to parse\n   * @param oldTree - Optional previous tree for incremental parsing\n   * @returns The parsed tree-sitter Tree\n   * @throws Error if parsing fails\n   */\n  function parseIncremental(source: string, oldTree?: T): T {\n    const tree = tsParser.parse(source, oldTree);\n    if (!tree) {\n      throw new Error(\"Failed to parse source\");\n    }\n    return tree;\n  }\n\n  /**\n   * Extract thalo code blocks from markdown source.\n   *\n   * Searches for fenced code blocks marked with ```thalo and extracts\n   * their content, creating a ParsedDocument with one ParsedBlock per\n   * code block found.\n   *\n   * @param source - The markdown source containing thalo code blocks\n   * @returns A ParsedDocument containing the extracted thalo blocks\n   */\n  function extractThaloBlocks(source: string): ParsedDocument<T> {\n    const blocks: ParsedBlock<T>[] = [];\n    let match: RegExpExecArray | null;\n\n    while ((match = THALO_FENCE_REGEX.exec(source)) !== null) {\n      const content = match[1];\n      const charOffset = match.index + match[0].indexOf(content);\n      const sourceMap = createSourceMap(source, charOffset, content);\n      blocks.push({\n        source: content,\n        sourceMap,\n        tree: parse(content),\n      });\n    }\n\n    THALO_FENCE_REGEX.lastIndex = 0;\n    return { blocks };\n  }\n\n  /**\n   * Parse a pure thalo document (not markdown).\n   *\n   * Creates a ParsedDocument with a single block containing the entire\n   * source as a thalo file.\n   *\n   * @param source - The thalo source code\n   * @returns A ParsedDocument with a single block\n   */\n  function parseThaloDocument(source: string): ParsedDocument<T> {\n    return {\n      blocks: [{ source, sourceMap: identitySourceMap(), tree: parse(source) }],\n    };\n  }\n\n  /**\n   * Parse a document, automatically detecting if it's a .thalo file or markdown\n   * with embedded thalo blocks.\n   *\n   * Uses fileType option, filename-based heuristics, or content-based heuristics\n   * to determine how to parse the source.\n   *\n   * @param source - The source code to parse\n   * @param options - Parse options including fileType and filename\n   * @returns A ParsedDocument containing one or more parsed blocks\n   */\n  function parseDocument(source: string, options: ParseOptions = {}): ParsedDocument<T> {\n    const { fileType, filename } = options;\n\n    if (fileType === \"thalo\") {\n      return parseThaloDocument(source);\n    }\n    if (fileType === \"markdown\") {\n      return extractThaloBlocks(source);\n    }\n\n    if (filename) {\n      const detected = detectFileType(filename);\n      if (detected === \"thalo\") {\n        return parseThaloDocument(source);\n      }\n      if (detected === \"markdown\") {\n        return extractThaloBlocks(source);\n      }\n    }\n\n    if (source.includes(\"```thalo\")) {\n      return extractThaloBlocks(source);\n    }\n\n    return parseThaloDocument(source);\n  }\n\n  return {\n    parse,\n    parseIncremental,\n    parseDocument,\n  };\n}\n"],"mappings":";;;;;;;AAmFA,MAAM,oBAAoB;;;;;;;AAQ1B,SAAgB,eAAe,UAAwC;AACrE,KAAI,SAAS,SAAS,SAAS,CAC7B,QAAO;AAET,KAAI,SAAS,SAAS,MAAM,CAC1B,QAAO;;;;;;;;AAsCX,SAAgB,kBACd,UACgB;;;;;;;;CAQhB,SAAS,MAAM,QAAmB;EAChC,MAAM,OAAO,SAAS,MAAM,OAAO;AACnC,MAAI,CAAC,KACH,OAAM,IAAI,MAAM,yBAAyB;AAE3C,SAAO;;;;;;;;;;CAWT,SAAS,iBAAiB,QAAgB,SAAgB;EACxD,MAAM,OAAO,SAAS,MAAM,QAAQ,QAAQ;AAC5C,MAAI,CAAC,KACH,OAAM,IAAI,MAAM,yBAAyB;AAE3C,SAAO;;;;;;;;;;;;CAaT,SAAS,mBAAmB,QAAmC;EAC7D,MAAMA,SAA2B,EAAE;EACnC,IAAIC;AAEJ,UAAQ,QAAQ,kBAAkB,KAAK,OAAO,MAAM,MAAM;GACxD,MAAM,UAAU,MAAM;GAEtB,MAAM,YAAY,gBAAgB,QADf,MAAM,QAAQ,MAAM,GAAG,QAAQ,QAAQ,EACJ,QAAQ;AAC9D,UAAO,KAAK;IACV,QAAQ;IACR;IACA,MAAM,MAAM,QAAQ;IACrB,CAAC;;AAGJ,oBAAkB,YAAY;AAC9B,SAAO,EAAE,QAAQ;;;;;;;;;;;CAYnB,SAAS,mBAAmB,QAAmC;AAC7D,SAAO,EACL,QAAQ,CAAC;GAAE;GAAQ,WAAW,mBAAmB;GAAE,MAAM,MAAM,OAAO;GAAE,CAAC,EAC1E;;;;;;;;;;;;;CAcH,SAAS,cAAc,QAAgB,UAAwB,EAAE,EAAqB;EACpF,MAAM,EAAE,UAAU,aAAa;AAE/B,MAAI,aAAa,QACf,QAAO,mBAAmB,OAAO;AAEnC,MAAI,aAAa,WACf,QAAO,mBAAmB,OAAO;AAGnC,MAAI,UAAU;GACZ,MAAM,WAAW,eAAe,SAAS;AACzC,OAAI,aAAa,QACf,QAAO,mBAAmB,OAAO;AAEnC,OAAI,aAAa,WACf,QAAO,mBAAmB,OAAO;;AAIrC,MAAI,OAAO,SAAS,WAAW,CAC7B,QAAO,mBAAmB,OAAO;AAGnC,SAAO,mBAAmB,OAAO;;AAGnC,QAAO;EACL;EACA;EACA;EACD"}

package/dist/parser.web.d.ts

@@ -0,0 +1,67 @@
+import { FileType, ParseOptions, ParsedBlock as ParsedBlock$1, ParsedDocument as ParsedDocument$1, ThaloParser } from "./parser.shared.js";
+import { Node, Tree, Tree as Tree$1 } from "web-tree-sitter";
+
+//#region src/parser.web.d.ts
+
+type ParsedBlock = ParsedBlock$1<Tree$1>;
+type ParsedDocument = ParsedDocument$1<Tree$1>;
+/**
+ * WASM input type - either raw bytes or a pre-compiled WebAssembly.Module.
+ *
+ * Use `WebAssembly.Module` in environments that support it (like Cloudflare Workers)
+ * or when you want to pre-compile the WASM for better performance.
+ */
+type WasmInput = Uint8Array | WebAssembly.Module;
+/**
+ * Options for creating a web parser.
+ */
+interface CreateParserOptions {
+  /**
+   * The web-tree-sitter runtime WASM.
+   * This is the `tree-sitter.wasm` file from the `web-tree-sitter` package.
+   *
+   * Can be provided as:
+   * - `Uint8Array`: Raw WASM bytes
+   * - `WebAssembly.Module`: Pre-compiled WASM module (useful for Cloudflare Workers, etc.)
+   */
+  treeSitterWasm: WasmInput;
+  /**
+   * The thalo language WASM.
+   * This is the `tree-sitter-thalo.wasm` file from `@rejot-dev/tree-sitter-thalo`.
+   *
+   * Can be provided as:
+   * - `Uint8Array`: Raw WASM bytes
+   * - `WebAssembly.Module`: Pre-compiled WASM module (useful for Cloudflare Workers, etc.)
+   */
+  languageWasm: WasmInput;
+}
+/**
+ * Create a web ThaloParser instance using WASM.
+ *
+ * This initializes web-tree-sitter and loads the thalo language WASM.
+ * Must be awaited before parsing.
+ *
+ * @example
+ * ```typescript
+ * import { createParser } from "@rejot-dev/thalo/web";
+ *
+ * // Option 1: Fetch both WASM files as bytes
+ * const [treeSitterWasm, languageWasm] = await Promise.all([
+ *   fetch("/wasm/tree-sitter.wasm").then(r => r.arrayBuffer()).then(b => new Uint8Array(b)),
+ *   fetch("/wasm/tree-sitter-thalo.wasm").then(r => r.arrayBuffer()).then(b => new Uint8Array(b)),
+ * ]);
+ *
+ * // Option 2: Use pre-compiled WebAssembly.Module (e.g., in Cloudflare Workers)
+ * // import treeSitterWasm from "./tree-sitter.wasm";
+ * // import languageWasm from "./tree-sitter-thalo.wasm";
+ *
+ * const parser = await createParser({ treeSitterWasm, languageWasm });
+ *
+ * const tree = parser.parse(source);
+ * const doc = parser.parseDocument(source, { fileType: "thalo" });
+ * ```
+ */
+declare function createParser(options: CreateParserOptions): Promise<ThaloParser<Tree$1>>;
+//#endregion
+export { CreateParserOptions, type FileType, type Node, type ParseOptions, ParsedBlock, ParsedDocument, type ThaloParser, type Tree, WasmInput, createParser };
+//# sourceMappingURL=parser.web.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parser.web.d.ts","names":[],"sources":["../src/parser.web.ts"],"sourcesContent":[],"mappings":";;;;;AA4BY,KAVA,WAAA,GAAc,aAUW,CAVQ,MAUR,CAAA;AAKpB,KAdL,cAAA,GAAiB,gBAiCb,CAjCmC,MAiCnC,CAAA;;;;;;;KAxBJ,SAAA,GAAY,aAAa,WAAA,CAAY;;;;UAKhC,mBAAA;;;;;;;;;kBASC;;;;;;;;;gBAUF;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BM,YAAA,UAAsB,sBAAsB,QAAQ,YAAY"}

package/dist/parser.web.js

@@ -0,0 +1,49 @@
+import { createThaloParser } from "./parser.shared.js";
+import { Language, Parser } from "web-tree-sitter";
+
+//#region src/parser.web.ts
+/**
+* Create a web ThaloParser instance using WASM.
+*
+* This initializes web-tree-sitter and loads the thalo language WASM.
+* Must be awaited before parsing.
+*
+* @example
+* ```typescript
+* import { createParser } from "@rejot-dev/thalo/web";
+*
+* // Option 1: Fetch both WASM files as bytes
+* const [treeSitterWasm, languageWasm] = await Promise.all([
+*   fetch("/wasm/tree-sitter.wasm").then(r => r.arrayBuffer()).then(b => new Uint8Array(b)),
+*   fetch("/wasm/tree-sitter-thalo.wasm").then(r => r.arrayBuffer()).then(b => new Uint8Array(b)),
+* ]);
+*
+* // Option 2: Use pre-compiled WebAssembly.Module (e.g., in Cloudflare Workers)
+* // import treeSitterWasm from "./tree-sitter.wasm";
+* // import languageWasm from "./tree-sitter-thalo.wasm";
+*
+* const parser = await createParser({ treeSitterWasm, languageWasm });
+*
+* const tree = parser.parse(source);
+* const doc = parser.parseDocument(source, { fileType: "thalo" });
+* ```
+*/
+async function createParser(options) {
+	const { treeSitterWasm, languageWasm } = options;
+	if (treeSitterWasm instanceof WebAssembly.Module) await Parser.init({ instantiateWasm: async (imports, successCallback) => {
+		const instance = await WebAssembly.instantiate(treeSitterWasm, imports);
+		successCallback(instance, treeSitterWasm);
+		return instance.exports;
+	} });
+	else await Parser.init({ wasmBinary: treeSitterWasm });
+	const tsParser = new Parser();
+	let language;
+	if (languageWasm instanceof WebAssembly.Module) language = Language.loadModuleSync(languageWasm);
+	else language = await Language.load(languageWasm);
+	tsParser.setLanguage(language);
+	return createThaloParser(tsParser);
+}
+
+//#endregion
+export { createParser };
+//# sourceMappingURL=parser.web.js.map

package/dist/parser.web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.web.js","names":["language: Language"],"sources":["../src/parser.web.ts"],"sourcesContent":["/**\n * Web (WASM) parser implementation using web-tree-sitter.\n */\n\nimport { Parser, Language, type Tree, type Node } from \"web-tree-sitter\";\nimport {\n  createThaloParser,\n  type ThaloParser,\n  type ParsedBlock as GenericParsedBlock,\n  type ParsedDocument as GenericParsedDocument,\n  type FileType,\n  type ParseOptions,\n} from \"./parser.shared.js\";\n\n// Re-export web-tree-sitter types for consumers\nexport type { Tree, Node } from \"web-tree-sitter\";\n\n// Re-export shared types specialized to web-tree-sitter Tree type\nexport type ParsedBlock = GenericParsedBlock<Tree>;\nexport type ParsedDocument = GenericParsedDocument<Tree>;\nexport type { FileType, ParseOptions, ThaloParser };\n\n/**\n * WASM input type - either raw bytes or a pre-compiled WebAssembly.Module.\n *\n * Use `WebAssembly.Module` in environments that support it (like Cloudflare Workers)\n * or when you want to pre-compile the WASM for better performance.\n */\nexport type WasmInput = Uint8Array | WebAssembly.Module;\n\n/**\n * Options for creating a web parser.\n */\nexport interface CreateParserOptions {\n  /**\n   * The web-tree-sitter runtime WASM.\n   * This is the `tree-sitter.wasm` file from the `web-tree-sitter` package.\n   *\n   * Can be provided as:\n   * - `Uint8Array`: Raw WASM bytes\n   * - `WebAssembly.Module`: Pre-compiled WASM module (useful for Cloudflare Workers, etc.)\n   */\n  treeSitterWasm: WasmInput;\n\n  /**\n   * The thalo language WASM.\n   * This is the `tree-sitter-thalo.wasm` file from `@rejot-dev/tree-sitter-thalo`.\n   *\n   * Can be provided as:\n   * - `Uint8Array`: Raw WASM bytes\n   * - `WebAssembly.Module`: Pre-compiled WASM module (useful for Cloudflare Workers, etc.)\n   */\n  languageWasm: WasmInput;\n}\n\n/**\n * Create a web ThaloParser instance using WASM.\n *\n * This initializes web-tree-sitter and loads the thalo language WASM.\n * Must be awaited before parsing.\n *\n * @example\n * ```typescript\n * import { createParser } from \"@rejot-dev/thalo/web\";\n *\n * // Option 1: Fetch both WASM files as bytes\n * const [treeSitterWasm, languageWasm] = await Promise.all([\n *   fetch(\"/wasm/tree-sitter.wasm\").then(r => r.arrayBuffer()).then(b => new Uint8Array(b)),\n *   fetch(\"/wasm/tree-sitter-thalo.wasm\").then(r => r.arrayBuffer()).then(b => new Uint8Array(b)),\n * ]);\n *\n * // Option 2: Use pre-compiled WebAssembly.Module (e.g., in Cloudflare Workers)\n * // import treeSitterWasm from \"./tree-sitter.wasm\";\n * // import languageWasm from \"./tree-sitter-thalo.wasm\";\n *\n * const parser = await createParser({ treeSitterWasm, languageWasm });\n *\n * const tree = parser.parse(source);\n * const doc = parser.parseDocument(source, { fileType: \"thalo\" });\n * ```\n */\nexport async function createParser(options: CreateParserOptions): Promise<ThaloParser<Tree>> {\n  const { treeSitterWasm, languageWasm } = options;\n\n  // Initialize the tree-sitter runtime\n  if (treeSitterWasm instanceof WebAssembly.Module) {\n    // Pre-compiled module: use instantiateWasm to provide it\n    // The callback expects (instance, module) - both the Instance and the Module\n    await Parser.init({\n      instantiateWasm: async (\n        imports: WebAssembly.Imports,\n        successCallback: (instance: WebAssembly.Instance, module: WebAssembly.Module) => void,\n      ) => {\n        const instance = await WebAssembly.instantiate(treeSitterWasm, imports);\n        // Pass both the instance AND the original module to the callback\n        successCallback(instance, treeSitterWasm);\n        return instance.exports;\n      },\n    });\n  } else {\n    // Raw bytes: use wasmBinary\n    await Parser.init({\n      wasmBinary: treeSitterWasm,\n    });\n  }\n\n  const tsParser = new Parser();\n\n  // Load the language - supports both Uint8Array and WebAssembly.Module\n  let language: Language;\n  if (languageWasm instanceof WebAssembly.Module) {\n    // Use our patched loadModuleSync method for pre-compiled modules (synchronous)\n    language = Language.loadModuleSync(languageWasm);\n  } else {\n    // Use standard load for bytes (async)\n    language = await Language.load(languageWasm);\n  }\n  tsParser.setLanguage(language);\n\n  return createThaloParser(tsParser);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiFA,eAAsB,aAAa,SAA0D;CAC3F,MAAM,EAAE,gBAAgB,iBAAiB;AAGzC,KAAI,0BAA0B,YAAY,OAGxC,OAAM,OAAO,KAAK,EAChB,iBAAiB,OACf,SACA,oBACG;EACH,MAAM,WAAW,MAAM,YAAY,YAAY,gBAAgB,QAAQ;AAEvE,kBAAgB,UAAU,eAAe;AACzC,SAAO,SAAS;IAEnB,CAAC;KAGF,OAAM,OAAO,KAAK,EAChB,YAAY,gBACb,CAAC;CAGJ,MAAM,WAAW,IAAI,QAAQ;CAG7B,IAAIA;AACJ,KAAI,wBAAwB,YAAY,OAEtC,YAAW,SAAS,eAAe,aAAa;KAGhD,YAAW,MAAM,SAAS,KAAK,aAAa;AAE9C,UAAS,YAAY,SAAS;AAE9B,QAAO,kBAAkB,SAAS"}

package/dist/schema/registry.d.ts

@@ -0,0 +1,108 @@
+import { ValueContent } from "../ast/ast-types.js";
+import { ModelDefaultValue, ModelSchemaEntry, ModelTypeExpression } from "../model/workspace.js";
+
+//#region src/schema/registry.d.ts
+
+/**
+ * A resolved entity schema (after applying all define-entity and alter-entity entries)
+ */
+interface EntitySchema {
+  /** The entity name */
+  name: string;
+  /** Description from the define-entity entry */
+  description: string;
+  /** Field definitions */
+  fields: Map<string, FieldSchema>;
+  /** Section definitions */
+  sections: Map<string, SectionSchema>;
+  /** Timestamp of the define-entity that created this schema */
+  definedAt: string;
+  /** File where this schema was defined */
+  definedIn: string;
+}
+/**
+ * A field schema in an entity definition
+ */
+interface FieldSchema {
+  /** Field name */
+  name: string;
+  /** Whether the field is optional */
+  optional: boolean;
+  /** The type expression */
+  type: ModelTypeExpression;
+  /** Default value (if any) */
+  defaultValue: ModelDefaultValue | null;
+  /** Description (if any) */
+  description: string | null;
+}
+/**
+ * A section schema in an entity definition
+ */
+interface SectionSchema {
+  /** Section name (PascalCase) */
+  name: string;
+  /** Whether the section is optional */
+  optional: boolean;
+  /** Description (if any) */
+  description: string | null;
+}
+/**
+ * Registry for entity schemas.
+ * Collects define-entity and alter-entity entries and resolves them into EntitySchemas.
+ */
+declare class SchemaRegistry {
+  private schemas;
+  private defineEntries;
+  private alterEntries;
+  /**
+   * Add a schema entry (define-entity or alter-entity)
+   */
+  add(entry: ModelSchemaEntry): void;
+  /**
+   * Get a resolved entity schema by name
+   */
+  get(name: string): EntitySchema | undefined;
+  /**
+   * Check if an entity is defined
+   */
+  has(name: string): boolean;
+  /**
+   * Get all defined entity names
+   */
+  entityNames(): string[];
+  /**
+   * Clear all schemas
+   */
+  clear(): void;
+  /**
+   * Resolve an entity schema from its define and alter entries
+   */
+  private resolve;
+  /**
+   * Apply an alter-entity entry to a schema
+   */
+  private applyAlter;
+}
+/**
+ * Type checking utilities for type expressions.
+ * Uses the grammar-parsed ValueContent for type validation.
+ */
+declare const TypeExpr: {
+  /**
+   * Check if a value content matches a type expression.
+   * This uses the grammar-parsed structure for reliable type checking.
+   */
+  matchesContent(content: ValueContent, type: ModelTypeExpression): boolean;
+  /**
+   * Check if a default value matches a type expression.
+   * Default values can only be quoted strings, links, or datetimes.
+   */
+  matchesDefaultValue(defaultValue: ModelDefaultValue, type: ModelTypeExpression): boolean;
+  /**
+   * Get a human-readable string for a type expression
+   */
+  toString(type: ModelTypeExpression): string;
+};
+//#endregion
+export { EntitySchema, FieldSchema, SchemaRegistry, SectionSchema, TypeExpr };
+//# sourceMappingURL=registry.d.ts.map

package/dist/schema/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","names":[],"sources":["../../src/schema/registry.ts"],"sourcesContent":[],"mappings":";;;;;;;AAsBA;AAMsB,UANL,YAAA,CAMK;EAAZ;EAEc,IAAA,EAAA,MAAA;EAAZ;EAAG,WAAA,EAAA,MAAA;EAUE;EAgBA,MAAA,EA5BP,GA4BO,CAAA,MAAa,EA5BR,WA4BQ,CAAA;EAajB;EAyLA,QAAA,EAhOD,GAkSX,CAAA,MAAA,EAlSuB,aAkSvB,CAAA;EA7DyB;EAAoB,SAAA,EAAA,MAAA;EAqBV;EAAyB,SAAA,EAAA,MAAA;;;;;UAhP5C,WAAA;;;;;;QAMT;;gBAEQ;;;;;;;UAQC,aAAA;;;;;;;;;;;;cAaJ,cAAA;;;;;;;aAQA;;;;qBAgBQ;;;;;;;;;;;;;;;;;;;;;;;;;;cAiKR;;;;;0BAKa,oBAAoB;;;;;oCAqBV,yBAAyB;;;;iBAsB5C"}