@rejot-dev/thalo 0.0.0

package/dist/model/line-index.d.ts

@@ -0,0 +1,85 @@
+//#region src/model/line-index.d.ts
+/**
+ * A simple position (line and column).
+ * Both are 0-based to match tree-sitter's Point type.
+ */
+interface Position {
+  /** 0-based line number */
+  line: number;
+  /** 0-based column number */
+  column: number;
+}
+/**
+ * Tree-sitter Point interface (row and column).
+ * Defined locally to avoid bundling native tree-sitter.
+ */
+interface Point {
+  row: number;
+  column: number;
+}
+/**
+ * LineIndex provides O(log n) offset-to-position and position-to-offset conversions.
+ * It maintains an array of line start offsets for efficient lookups.
+ */
+declare class LineIndex {
+  /** Array of character offsets where each line starts */
+  private readonly lineStarts;
+  /** Total length of the source text */
+  private readonly length;
+  constructor(source: string);
+  /**
+   * Get the number of lines in the source.
+   */
+  get lineCount(): number;
+  /**
+   * Convert a character offset to a Position (line, column).
+   * Uses binary search for O(log n) performance.
+   *
+   * @param offset - 0-based character offset
+   * @returns Position with 0-based line and column
+   */
+  offsetToPosition(offset: number): Position;
+  /**
+   * Convert a Position to a character offset.
+   *
+   * @param position - Position with 0-based line and column
+   * @returns 0-based character offset
+   */
+  positionToOffset(position: Position): number;
+  /**
+   * Convert a character offset to a tree-sitter Point.
+   */
+  offsetToPoint(offset: number): Point;
+  /**
+   * Convert a tree-sitter Point to a character offset.
+   */
+  pointToOffset(point: Point): number;
+  /**
+   * Get the character offset where a line starts.
+   *
+   * @param line - 0-based line number
+   * @returns Character offset, or -1 if line is out of range
+   */
+  getLineStart(line: number): number;
+  /**
+   * Get the character offset where a line ends (before the newline).
+   *
+   * @param line - 0-based line number
+   * @returns Character offset, or -1 if line is out of range
+   */
+  getLineEnd(line: number): number;
+  /**
+   * Create a new LineIndex with an edit applied.
+   * This is useful for computing edit ranges for tree-sitter.
+   *
+   * @param startOffset - Start of the edit range
+   * @param oldEndOffset - End of the old text being replaced
+   * @param newText - The new text being inserted
+   * @param fullNewSource - The complete new source text
+   * @returns A new LineIndex for the edited source
+   */
+  static fromEdit(_startOffset: number, _oldEndOffset: number, _newText: string, fullNewSource: string): LineIndex;
+}
+//#endregion
+export { LineIndex, Position };
+//# sourceMappingURL=line-index.d.ts.map

package/dist/model/line-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-index.d.ts","names":[],"sources":["../../src/model/line-index.ts"],"sourcesContent":[],"mappings":";;AAIA;AAKC;AAeD;AA+BoC,UAnDnB,QAAA,CAmDmB;EA6BP;EAuBI,IAAA,EAAA,MAAA;EAQV;EAiDlB,MAAA,EAAA,MAAA;;;;;;UArJK,KAAA;;;;;;;;cASG,SAAA;;;;;;;;;;;;;;;;;oCA+BuB;;;;;;;6BA6BP;;;;iCAuBI;;;;uBAQV;;;;;;;;;;;;;;;;;;;;;;;;;yGAiDlB"}

package/dist/model/line-index.js

@@ -0,0 +1,159 @@
+//#region src/model/line-index.ts
+/**
+* LineIndex provides O(log n) offset-to-position and position-to-offset conversions.
+* It maintains an array of line start offsets for efficient lookups.
+*/
+var LineIndex = class LineIndex {
+	/** Array of character offsets where each line starts */
+	lineStarts;
+	/** Total length of the source text */
+	length;
+	constructor(source) {
+		this.lineStarts = [0];
+		this.length = source.length;
+		for (let i = 0; i < source.length; i++) if (source[i] === "\n") this.lineStarts.push(i + 1);
+	}
+	/**
+	* Get the number of lines in the source.
+	*/
+	get lineCount() {
+		return this.lineStarts.length;
+	}
+	/**
+	* Convert a character offset to a Position (line, column).
+	* Uses binary search for O(log n) performance.
+	*
+	* @param offset - 0-based character offset
+	* @returns Position with 0-based line and column
+	*/
+	offsetToPosition(offset) {
+		const clampedOffset = Math.max(0, Math.min(offset, this.length));
+		let low = 0;
+		let high = this.lineStarts.length - 1;
+		while (low < high) {
+			const mid = Math.floor((low + high + 1) / 2);
+			if (this.lineStarts[mid] <= clampedOffset) low = mid;
+			else high = mid - 1;
+		}
+		const line = low;
+		return {
+			line,
+			column: clampedOffset - this.lineStarts[line]
+		};
+	}
+	/**
+	* Convert a Position to a character offset.
+	*
+	* @param position - Position with 0-based line and column
+	* @returns 0-based character offset
+	*/
+	positionToOffset(position) {
+		const { line, column } = position;
+		const clampedLine = Math.max(0, Math.min(line, this.lineStarts.length - 1));
+		const lineStart = this.lineStarts[clampedLine];
+		const maxColumn = (clampedLine < this.lineStarts.length - 1 ? this.lineStarts[clampedLine + 1] - 1 : this.length) - lineStart;
+		return lineStart + Math.max(0, Math.min(column, maxColumn));
+	}
+	/**
+	* Convert a character offset to a tree-sitter Point.
+	*/
+	offsetToPoint(offset) {
+		const pos = this.offsetToPosition(offset);
+		return {
+			row: pos.line,
+			column: pos.column
+		};
+	}
+	/**
+	* Convert a tree-sitter Point to a character offset.
+	*/
+	pointToOffset(point) {
+		return this.positionToOffset({
+			line: point.row,
+			column: point.column
+		});
+	}
+	/**
+	* Get the character offset where a line starts.
+	*
+	* @param line - 0-based line number
+	* @returns Character offset, or -1 if line is out of range
+	*/
+	getLineStart(line) {
+		if (line < 0 || line >= this.lineStarts.length) return -1;
+		return this.lineStarts[line];
+	}
+	/**
+	* Get the character offset where a line ends (before the newline).
+	*
+	* @param line - 0-based line number
+	* @returns Character offset, or -1 if line is out of range
+	*/
+	getLineEnd(line) {
+		if (line < 0 || line >= this.lineStarts.length) return -1;
+		if (line === this.lineStarts.length - 1) return this.length;
+		return this.lineStarts[line + 1] - 1;
+	}
+	/**
+	* Create a new LineIndex with an edit applied.
+	* This is useful for computing edit ranges for tree-sitter.
+	*
+	* @param startOffset - Start of the edit range
+	* @param oldEndOffset - End of the old text being replaced
+	* @param newText - The new text being inserted
+	* @param fullNewSource - The complete new source text
+	* @returns A new LineIndex for the edited source
+	*/
+	static fromEdit(_startOffset, _oldEndOffset, _newText, fullNewSource) {
+		return new LineIndex(fullNewSource);
+	}
+};
+/**
+* Compute tree-sitter edit parameters from an LSP-style text edit.
+*
+* @param lineIndex - The line index for the current source
+* @param startLine - 0-based start line
+* @param startColumn - 0-based start column
+* @param endLine - 0-based end line
+* @param endColumn - 0-based end column
+* @param newText - The replacement text
+* @returns Edit parameters for tree-sitter's Tree.edit()
+*/
+function computeEdit(lineIndex, startLine, startColumn, endLine, endColumn, newText) {
+	const startIndex = lineIndex.positionToOffset({
+		line: startLine,
+		column: startColumn
+	});
+	const oldEndIndex = lineIndex.positionToOffset({
+		line: endLine,
+		column: endColumn
+	});
+	const newEndIndex = startIndex + newText.length;
+	let newEndLine = startLine;
+	let newEndColumn = startColumn;
+	for (const char of newText) if (char === "\n") {
+		newEndLine++;
+		newEndColumn = 0;
+	} else newEndColumn++;
+	return {
+		startIndex,
+		oldEndIndex,
+		newEndIndex,
+		startPosition: {
+			row: startLine,
+			column: startColumn
+		},
+		oldEndPosition: {
+			row: endLine,
+			column: endColumn
+		},
+		newEndPosition: {
+			row: newEndLine,
+			column: newEndColumn
+		}
+	};
+}
+
+//#endregion
+export { LineIndex, computeEdit };
+//# sourceMappingURL=line-index.js.map

package/dist/model/line-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-index.js","names":[],"sources":["../../src/model/line-index.ts"],"sourcesContent":["/**\n * A simple position (line and column).\n * Both are 0-based to match tree-sitter's Point type.\n */\nexport interface Position {\n  /** 0-based line number */\n  line: number;\n  /** 0-based column number */\n  column: number;\n}\n\n/**\n * Tree-sitter Point interface (row and column).\n * Defined locally to avoid bundling native tree-sitter.\n */\ninterface Point {\n  row: number;\n  column: number;\n}\n\n/**\n * LineIndex provides O(log n) offset-to-position and position-to-offset conversions.\n * It maintains an array of line start offsets for efficient lookups.\n */\nexport class LineIndex {\n  /** Array of character offsets where each line starts */\n  private readonly lineStarts: number[];\n  /** Total length of the source text */\n  private readonly length: number;\n\n  constructor(source: string) {\n    this.lineStarts = [0]; // Line 0 starts at offset 0\n    this.length = source.length;\n\n    for (let i = 0; i < source.length; i++) {\n      if (source[i] === \"\\n\") {\n        this.lineStarts.push(i + 1);\n      }\n    }\n  }\n\n  /**\n   * Get the number of lines in the source.\n   */\n  get lineCount(): number {\n    return this.lineStarts.length;\n  }\n\n  /**\n   * Convert a character offset to a Position (line, column).\n   * Uses binary search for O(log n) performance.\n   *\n   * @param offset - 0-based character offset\n   * @returns Position with 0-based line and column\n   */\n  offsetToPosition(offset: number): Position {\n    // Clamp offset to valid range\n    const clampedOffset = Math.max(0, Math.min(offset, this.length));\n\n    // Binary search to find the line\n    let low = 0;\n    let high = this.lineStarts.length - 1;\n\n    while (low < high) {\n      const mid = Math.floor((low + high + 1) / 2);\n      if (this.lineStarts[mid] <= clampedOffset) {\n        low = mid;\n      } else {\n        high = mid - 1;\n      }\n    }\n\n    const line = low;\n    const column = clampedOffset - this.lineStarts[line];\n\n    return { line, column };\n  }\n\n  /**\n   * Convert a Position to a character offset.\n   *\n   * @param position - Position with 0-based line and column\n   * @returns 0-based character offset\n   */\n  positionToOffset(position: Position): number {\n    const { line, column } = position;\n\n    // Clamp line to valid range\n    const clampedLine = Math.max(0, Math.min(line, this.lineStarts.length - 1));\n    const lineStart = this.lineStarts[clampedLine];\n\n    // Calculate max column for this line\n    const lineEnd =\n      clampedLine < this.lineStarts.length - 1\n        ? this.lineStarts[clampedLine + 1] - 1 // Don't include the newline\n        : this.length;\n    const maxColumn = lineEnd - lineStart;\n\n    // Clamp column to valid range\n    const clampedColumn = Math.max(0, Math.min(column, maxColumn));\n\n    return lineStart + clampedColumn;\n  }\n\n  /**\n   * Convert a character offset to a tree-sitter Point.\n   */\n  offsetToPoint(offset: number): Point {\n    const pos = this.offsetToPosition(offset);\n    return { row: pos.line, column: pos.column };\n  }\n\n  /**\n   * Convert a tree-sitter Point to a character offset.\n   */\n  pointToOffset(point: Point): number {\n    return this.positionToOffset({ line: point.row, column: point.column });\n  }\n\n  /**\n   * Get the character offset where a line starts.\n   *\n   * @param line - 0-based line number\n   * @returns Character offset, or -1 if line is out of range\n   */\n  getLineStart(line: number): number {\n    if (line < 0 || line >= this.lineStarts.length) {\n      return -1;\n    }\n    return this.lineStarts[line];\n  }\n\n  /**\n   * Get the character offset where a line ends (before the newline).\n   *\n   * @param line - 0-based line number\n   * @returns Character offset, or -1 if line is out of range\n   */\n  getLineEnd(line: number): number {\n    if (line < 0 || line >= this.lineStarts.length) {\n      return -1;\n    }\n    if (line === this.lineStarts.length - 1) {\n      return this.length;\n    }\n    // Return position before the newline character\n    return this.lineStarts[line + 1] - 1;\n  }\n\n  /**\n   * Create a new LineIndex with an edit applied.\n   * This is useful for computing edit ranges for tree-sitter.\n   *\n   * @param startOffset - Start of the edit range\n   * @param oldEndOffset - End of the old text being replaced\n   * @param newText - The new text being inserted\n   * @param fullNewSource - The complete new source text\n   * @returns A new LineIndex for the edited source\n   */\n  static fromEdit(\n    _startOffset: number,\n    _oldEndOffset: number,\n    _newText: string,\n    fullNewSource: string,\n  ): LineIndex {\n    // For now, just rebuild from scratch\n    // A more sophisticated implementation could incrementally update lineStarts\n    return new LineIndex(fullNewSource);\n  }\n}\n\n/**\n * Compute tree-sitter edit parameters from an LSP-style text edit.\n *\n * @param lineIndex - The line index for the current source\n * @param startLine - 0-based start line\n * @param startColumn - 0-based start column\n * @param endLine - 0-based end line\n * @param endColumn - 0-based end column\n * @param newText - The replacement text\n * @returns Edit parameters for tree-sitter's Tree.edit()\n */\nexport function computeEdit(\n  lineIndex: LineIndex,\n  startLine: number,\n  startColumn: number,\n  endLine: number,\n  endColumn: number,\n  newText: string,\n): {\n  startIndex: number;\n  oldEndIndex: number;\n  newEndIndex: number;\n  startPosition: Point;\n  oldEndPosition: Point;\n  newEndPosition: Point;\n} {\n  const startIndex = lineIndex.positionToOffset({ line: startLine, column: startColumn });\n  const oldEndIndex = lineIndex.positionToOffset({ line: endLine, column: endColumn });\n\n  // Calculate the new end position\n  const newEndIndex = startIndex + newText.length;\n\n  // Count lines in the new text to determine new end position\n  let newEndLine = startLine;\n  let newEndColumn = startColumn;\n\n  for (const char of newText) {\n    if (char === \"\\n\") {\n      newEndLine++;\n      newEndColumn = 0;\n    } else {\n      newEndColumn++;\n    }\n  }\n\n  return {\n    startIndex,\n    oldEndIndex,\n    newEndIndex,\n    startPosition: { row: startLine, column: startColumn },\n    oldEndPosition: { row: endLine, column: endColumn },\n    newEndPosition: { row: newEndLine, column: newEndColumn },\n  };\n}\n"],"mappings":";;;;;AAwBA,IAAa,YAAb,MAAa,UAAU;;CAErB,AAAiB;;CAEjB,AAAiB;CAEjB,YAAY,QAAgB;AAC1B,OAAK,aAAa,CAAC,EAAE;AACrB,OAAK,SAAS,OAAO;AAErB,OAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,IACjC,KAAI,OAAO,OAAO,KAChB,MAAK,WAAW,KAAK,IAAI,EAAE;;;;;CAQjC,IAAI,YAAoB;AACtB,SAAO,KAAK,WAAW;;;;;;;;;CAUzB,iBAAiB,QAA0B;EAEzC,MAAM,gBAAgB,KAAK,IAAI,GAAG,KAAK,IAAI,QAAQ,KAAK,OAAO,CAAC;EAGhE,IAAI,MAAM;EACV,IAAI,OAAO,KAAK,WAAW,SAAS;AAEpC,SAAO,MAAM,MAAM;GACjB,MAAM,MAAM,KAAK,OAAO,MAAM,OAAO,KAAK,EAAE;AAC5C,OAAI,KAAK,WAAW,QAAQ,cAC1B,OAAM;OAEN,QAAO,MAAM;;EAIjB,MAAM,OAAO;AAGb,SAAO;GAAE;GAAM,QAFA,gBAAgB,KAAK,WAAW;GAExB;;;;;;;;CASzB,iBAAiB,UAA4B;EAC3C,MAAM,EAAE,MAAM,WAAW;EAGzB,MAAM,cAAc,KAAK,IAAI,GAAG,KAAK,IAAI,MAAM,KAAK,WAAW,SAAS,EAAE,CAAC;EAC3E,MAAM,YAAY,KAAK,WAAW;EAOlC,MAAM,aAHJ,cAAc,KAAK,WAAW,SAAS,IACnC,KAAK,WAAW,cAAc,KAAK,IACnC,KAAK,UACiB;AAK5B,SAAO,YAFe,KAAK,IAAI,GAAG,KAAK,IAAI,QAAQ,UAAU,CAAC;;;;;CAQhE,cAAc,QAAuB;EACnC,MAAM,MAAM,KAAK,iBAAiB,OAAO;AACzC,SAAO;GAAE,KAAK,IAAI;GAAM,QAAQ,IAAI;GAAQ;;;;;CAM9C,cAAc,OAAsB;AAClC,SAAO,KAAK,iBAAiB;GAAE,MAAM,MAAM;GAAK,QAAQ,MAAM;GAAQ,CAAC;;;;;;;;CASzE,aAAa,MAAsB;AACjC,MAAI,OAAO,KAAK,QAAQ,KAAK,WAAW,OACtC,QAAO;AAET,SAAO,KAAK,WAAW;;;;;;;;CASzB,WAAW,MAAsB;AAC/B,MAAI,OAAO,KAAK,QAAQ,KAAK,WAAW,OACtC,QAAO;AAET,MAAI,SAAS,KAAK,WAAW,SAAS,EACpC,QAAO,KAAK;AAGd,SAAO,KAAK,WAAW,OAAO,KAAK;;;;;;;;;;;;CAarC,OAAO,SACL,cACA,eACA,UACA,eACW;AAGX,SAAO,IAAI,UAAU,cAAc;;;;;;;;;;;;;;AAevC,SAAgB,YACd,WACA,WACA,aACA,SACA,WACA,SAQA;CACA,MAAM,aAAa,UAAU,iBAAiB;EAAE,MAAM;EAAW,QAAQ;EAAa,CAAC;CACvF,MAAM,cAAc,UAAU,iBAAiB;EAAE,MAAM;EAAS,QAAQ;EAAW,CAAC;CAGpF,MAAM,cAAc,aAAa,QAAQ;CAGzC,IAAI,aAAa;CACjB,IAAI,eAAe;AAEnB,MAAK,MAAM,QAAQ,QACjB,KAAI,SAAS,MAAM;AACjB;AACA,iBAAe;OAEf;AAIJ,QAAO;EACL;EACA;EACA;EACA,eAAe;GAAE,KAAK;GAAW,QAAQ;GAAa;EACtD,gBAAgB;GAAE,KAAK;GAAS,QAAQ;GAAW;EACnD,gBAAgB;GAAE,KAAK;GAAY,QAAQ;GAAc;EAC1D"}

package/dist/model/workspace.d.ts

@@ -0,0 +1,296 @@
+import { ActualizeEntry, Entry, InstanceEntry, Location, SchemaEntry, SynthesisEntry } from "../ast/ast-types.js";
+import { SourceMap } from "../source-map.js";
+import { FileType, GenericTree, ThaloParser } from "../parser.shared.js";
+import { LinkDefinition, LinkIndex, LinkReference, SemanticModel } from "../semantic/analyzer.js";
+import { SchemaRegistry } from "../schema/registry.js";
+import { Document } from "./document.js";
+
+//#region src/model/workspace.d.ts
+/**
+ * A schema entry (define-entity/alter-entity)
+ */
+interface ModelSchemaEntry {
+  kind: "schema";
+  /** The timestamp from the header */
+  timestamp: string;
+  /** The directive (define-entity or alter-entity) */
+  directive: "define-entity" | "alter-entity";
+  /** The entity name being defined/altered */
+  entityName: string;
+  /** The title/description */
+  title: string;
+  /** Explicit link ID from header (if any) */
+  linkId: string | null;
+  /** Tags from the header */
+  tags: string[];
+  /** Field definitions (for define/alter) */
+  fields: ModelFieldDefinition[];
+  /** Section definitions (for define/alter) */
+  sections: ModelSectionDefinition[];
+  /** Field removals (for alter) */
+  removeFields: string[];
+  /** Section removals (for alter) */
+  removeSections: string[];
+  /** Location in source (block-relative) */
+  location: Location;
+  /** The file path containing this entry */
+  file: string;
+  /** Source map for translating block-relative to file-absolute positions */
+  sourceMap: SourceMap;
+}
+/**
+ * A field definition from a schema entry
+ */
+interface ModelFieldDefinition {
+  name: string;
+  optional: boolean;
+  type: ModelTypeExpression;
+  /** The typed default value content (quoted, link, or datetime) */
+  defaultValue: ModelDefaultValue | null;
+  description: string | null;
+  location: Location;
+}
+/**
+ * A typed default value from a field definition.
+ * Can be a quoted string, link reference, datetime, or number.
+ */
+type ModelDefaultValue = {
+  kind: "quoted";
+  value: string;
+  raw: string;
+} | {
+  kind: "link";
+  id: string;
+  raw: string;
+} | {
+  kind: "datetime";
+  value: string;
+  raw: string;
+} | {
+  kind: "number";
+  value: number;
+  raw: string;
+};
+/**
+ * A section definition from a schema entry
+ */
+interface ModelSectionDefinition {
+  name: string;
+  optional: boolean;
+  description: string | null;
+  location: Location;
+}
+/**
+ * Type expressions in field definitions
+ */
+type ModelTypeExpression = ModelPrimitiveType | ModelLiteralType | ModelArrayType | ModelUnionType | ModelUnknownType;
+interface ModelPrimitiveType {
+  kind: "primitive";
+  name: "string" | "datetime" | "daterange" | "link" | "number";
+}
+/**
+ * An unknown/invalid type (e.g., typo like "date-time" instead of "datetime").
+ * Fields with this type are included in the schema but type validation is skipped.
+ */
+interface ModelUnknownType {
+  kind: "unknown";
+  /** The unrecognized type name as written */
+  name: string;
+}
+interface ModelLiteralType {
+  kind: "literal";
+  value: string;
+}
+interface ModelArrayType {
+  kind: "array";
+  elementType: ModelPrimitiveType | ModelLiteralType | ModelUnionType | ModelUnknownType;
+}
+interface ModelUnionType {
+  kind: "union";
+  members: (ModelPrimitiveType | ModelLiteralType | ModelArrayType | ModelUnknownType)[];
+}
+/**
+ * Options for adding a document to the workspace
+ */
+interface AddDocumentOptions {
+  /** The file type. If not provided, uses heuristics based on filename or content. */
+  fileType?: FileType;
+  /** The filename/path for the document (required for workspace indexing) */
+  filename: string;
+}
+/**
+ * Result of applying an edit or update to the workspace.
+ * Used for incremental diagnostics and targeted invalidation.
+ */
+interface InvalidationResult {
+  /** Files whose diagnostics may have changed */
+  affectedFiles: string[];
+  /** Whether schema definitions changed (affects type checking) */
+  schemasChanged: boolean;
+  /** Whether link definitions changed (affects link resolution) */
+  linksChanged: boolean;
+  /** Entity names whose schemas changed */
+  changedEntityNames: string[];
+  /** Link IDs that were added or removed */
+  changedLinkIds: string[];
+}
+/**
+ * A workspace containing multiple thalo documents.
+ * Provides cross-file link resolution and schema management.
+ *
+ * The workspace is parser-agnostic - it accepts any parser that implements
+ * the ThaloParser interface, allowing it to work with both native (Node.js)
+ * and web (WASM) tree-sitter implementations.
+ *
+ * @example
+ * ```typescript
+ * // With native parser (Node.js) - parser is optional, defaults to native
+ * import { Workspace } from "@rejot-dev/thalo";
+ * const workspace = new Workspace();
+ *
+ * // With explicit parser
+ * import { createParser } from "@rejot-dev/thalo/native";
+ * const parser = createParser();
+ * const workspace = new Workspace(parser);
+ *
+ * // With web parser (browser)
+ * import { createParser } from "@rejot-dev/thalo/web";
+ * const parser = await createParser({ treeSitterWasm, languageWasm });
+ * const workspace = new Workspace(parser);
+ * ```
+ */
+declare class Workspace {
+  private parser;
+  private models;
+  private documents;
+  private _schemaRegistry;
+  private _linkIndex;
+  private linkDependencies;
+  private entityDependencies;
+  /**
+   * Create a new Workspace.
+   *
+   * @param parser - A ThaloParser instance. For Node.js, use createParser() from "@rejot-dev/thalo".
+   *                 For browser, use createParser() from "@rejot-dev/thalo/web".
+   */
+  constructor(parser: ThaloParser<GenericTree>);
+  /**
+   * Get the schema registry for this workspace
+   */
+  get schemaRegistry(): SchemaRegistry;
+  /**
+   * Get the combined link index for all documents.
+   */
+  get linkIndex(): LinkIndex;
+  /**
+   * Add a document to the workspace.
+   */
+  addDocument(source: string, options: AddDocumentOptions): SemanticModel;
+  /**
+   * Remove a document from the workspace
+   */
+  removeDocument(file: string): void;
+  /**
+   * Get a SemanticModel by file path.
+   */
+  getModel(file: string): SemanticModel | undefined;
+  /**
+   * Check if a document exists
+   */
+  hasDocument(file: string): boolean;
+  /**
+   * Get all document file paths
+   */
+  files(): string[];
+  /**
+   * Get all SemanticModels.
+   */
+  allModels(): SemanticModel[];
+  /**
+   * Get all AST entries across all SemanticModels.
+   */
+  allEntries(): Entry[];
+  /**
+   * Get all instance entries (create/update) across all SemanticModels.
+   */
+  allInstanceEntries(): InstanceEntry[];
+  /**
+   * Get all schema entries (define-entity/alter-entity) across all SemanticModels.
+   */
+  allSchemaEntries(): SchemaEntry[];
+  /**
+   * Get all synthesis entries (define-synthesis) across all SemanticModels.
+   */
+  allSynthesisEntries(): SynthesisEntry[];
+  /**
+   * Get all actualize entries (actualize-synthesis) across all SemanticModels.
+   */
+  allActualizeEntries(): ActualizeEntry[];
+  /**
+   * Get the definition for a link ID
+   */
+  getLinkDefinition(id: string): LinkDefinition | undefined;
+  /**
+   * Get all references for a link ID
+   */
+  getLinkReferences(id: string): LinkReference[];
+  /**
+   * Get the Document instance for incremental editing.
+   * Returns undefined if the document hasn't been added with incremental support.
+   */
+  getDocument(file: string): Document<GenericTree> | undefined;
+  /**
+   * Apply an incremental edit to a document.
+   * This is more efficient than addDocument() for small edits.
+   *
+   * @param filename - The file to edit
+   * @param startLine - 0-based start line
+   * @param startColumn - 0-based start column
+   * @param endLine - 0-based end line
+   * @param endColumn - 0-based end column
+   * @param newText - The replacement text
+   * @returns Information about what was invalidated
+   */
+  applyEdit(filename: string, startLine: number, startColumn: number, endLine: number, endColumn: number, newText: string): InvalidationResult;
+  /**
+   * Update a document with new content.
+   * This replaces the entire document and recalculates all dependencies.
+   *
+   * @param filename - The file to update
+   * @param newSource - The new source content
+   * @returns Information about what was invalidated
+   */
+  updateDocument(filename: string, newSource: string): InvalidationResult;
+  /**
+   * Get files that would be affected by changes in a specific file.
+   * Useful for targeted diagnostics refresh.
+   */
+  getAffectedFiles(filename: string): string[];
+  /**
+   * Clear all documents
+   */
+  clear(): void;
+  /**
+   * Rebuild schema registry and link index from all models
+   */
+  private rebuild;
+  /**
+   * Merge a SemanticModel's links into the workspace link index
+   */
+  private mergeLinks;
+  /**
+   * Update entity dependencies for a model
+   */
+  private updateEntityDependencies;
+  /**
+   * Remove a file's dependencies from the tracking maps
+   */
+  private removeDependencies;
+  /**
+   * Update the semantic model from a Document's parse results.
+   */
+  private updateModelFromDocument;
+}
+//#endregion
+export { InvalidationResult, ModelDefaultValue, ModelFieldDefinition, ModelSchemaEntry, ModelSectionDefinition, ModelTypeExpression, Workspace };
+//# sourceMappingURL=workspace.d.ts.map

package/dist/model/workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","names":[],"sources":["../../src/model/workspace.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;UAUiB,gBAAA;;;EAAA,SAAA,EAAA,MAAA;EAeP;EAEE,SAAA,EAAA,eAAA,GAAA,cAAA;EAMA;EAIC,UAAA,EAAA,MAAA;EAAS;EAML,KAAA,EAAA,MAAA;EAGT;EAEQ,MAAA,EAAA,MAAA,GAAA,IAAA;EAEJ;EAAQ,IAAA,EAAA,MAAA,EAAA;EAOR;EASK,MAAA,EAzCP,oBAyC6B,EAAA;EAU3B;EACR,QAAA,EAlDQ,sBAkDR,EAAA;EACA;EACA,YAAA,EAAA,MAAA,EAAA;EACA;EACA,cAAA,EAAA,MAAA,EAAA;EAAgB;EAEH,QAAA,EAlDL,QAkDK;EASA;EAMA,IAAA,EAAA,MAAA;EAKA;EAEF,SAAA,EApEF,SAoEE;;;;;AAGE,UAjEA,oBAAA,CAiEc;EAEnB,IAAA,EAAA,MAAA;EAAqB,QAAA,EAAA,OAAA;EAAmB,IAAA,EAhE5C,mBAgE4C;EAAiB;EAAgB,YAAA,EA9DrE,iBA8DqE,GAAA,IAAA;EA+BpE,WAAA,EAAA,MAAA,GAAkB,IAAA;EAWlB,QAAA,EAtGL,QAsGK;AAsCjB;;;;;AA2CuC,KAhL3B,iBAAA,GAgL2B;EAAqB,IAAA,EAAA,QAAA;EAgFlC,KAAA,EAAA,MAAA;EAqBX,GAAA,EAAA,MAAA;CAOC,GAAA;EAWQ,IAAA,EAAA,MAAA;EAOF,EAAA,EAAA,MAAA;EAOG,GAAA,EAAA,MAAA;CAOA,GAAA;EAOQ,IAAA,EAAA,UAAA;EAOA,KAAA,EAAA,MAAA;EAQK,GAAA,EAAA,MAAA;CAAT,GAAA;EAuBxB,IAAA,EAAA,QAAA;EAsCkD,KAAA,EAAA,MAAA;EAAkB,GAAA,EAAA,MAAA;;;;;UAtYxD,sBAAA;;;;YAIL;;;;;KAMA,mBAAA,GACR,qBACA,mBACA,iBACA,iBACA;UAEa,kBAAA;;;;;;;;UASA,gBAAA;;;;;UAMA,gBAAA;;;;UAKA,cAAA;;eAEF,qBAAqB,mBAAmB,iBAAiB;;UAGvD,cAAA;;YAEL,qBAAqB,mBAAmB,iBAAiB;;;;;UA+BpD,kBAAA;;aAEJ;;;;;;;;UASI,kBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCJ,SAAA;;;;;;;;;;;;;;sBAsBS,YAAY;;;;wBAOV;;;;mBAOL;;;;uCAOoB,qBAAqB;;;;;;;;0BAgFlC;;;;;;;;;;;;eAqBX;;;;gBAOC;;;;wBAWQ;;;;sBAOF;;;;yBAOG;;;;yBAOA;;;;iCAOQ;;;;iCAOA;;;;;6BAQJ,SAAS;;;;;;;;;;;;;4HAuBjC;;;;;;;;;uDAsCkD"}