@rejot-dev/thalo 0.0.0

package/dist/merge/merge-result-builder.js

@@ -0,0 +1,89 @@
+import { serializeIdentity } from "./entry-matcher.js";
+import { formatConflict, formatEntry } from "./conflict-formatter.js";
+import { entriesEqual, mergeEntry } from "./entry-merger.js";
+
+//#region src/merge/merge-result-builder.ts
+/**
+* Build the final merged result from matches and conflicts
+*
+* @param matches - Array of matched entry triplets
+* @param conflicts - Array of detected conflicts
+* @param options - Merge options
+* @returns Complete merge result with content and statistics
+*/
+function buildMergedResult(matches, conflicts, options = {}) {
+	const conflictMap = /* @__PURE__ */ new Map();
+	for (const conflict of conflicts) {
+		const key = serializeIdentity(conflict.identity);
+		conflictMap.set(key, conflict);
+	}
+	const lines = [];
+	const stats = {
+		totalEntries: 0,
+		oursOnly: 0,
+		theirsOnly: 0,
+		common: 0,
+		autoMerged: 0,
+		conflicts: conflicts.length
+	};
+	const sortedMatches = sortMatchesByTimestamp(matches);
+	for (const match of sortedMatches) {
+		const matchKey = serializeIdentity(match.identity);
+		const conflict = conflictMap.get(matchKey);
+		if (conflict) {
+			const conflictLines = formatConflict(conflict, options);
+			conflict.location = lines.length + 1;
+			lines.push(...conflictLines);
+			lines.push("");
+		} else {
+			const merged = mergeEntry(match);
+			if (merged) {
+				lines.push(...formatEntry(merged));
+				lines.push("");
+				stats.totalEntries++;
+				if (!match.base && match.ours && !match.theirs) stats.oursOnly++;
+				else if (!match.base && !match.ours && match.theirs) stats.theirsOnly++;
+				else if (match.base && match.ours && match.theirs) if (entriesEqual(match.base, match.ours) && entriesEqual(match.base, match.theirs)) stats.common++;
+				else stats.autoMerged++;
+			}
+		}
+	}
+	if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+	return {
+		success: conflicts.length === 0,
+		content: lines.join("\n"),
+		conflicts,
+		stats
+	};
+}
+/**
+* Sort matches by timestamp for chronological output
+*/
+function sortMatchesByTimestamp(matches) {
+	return [...matches].sort((a, b) => {
+		const tsA = getMatchTimestamp(a);
+		const tsB = getMatchTimestamp(b);
+		if (!tsA && !tsB) return 0;
+		if (!tsA) return 1;
+		if (!tsB) return -1;
+		return tsA.localeCompare(tsB);
+	});
+}
+/**
+* Get timestamp from a match (prefer ours, then theirs, then base)
+*/
+function getMatchTimestamp(match) {
+	const entry = match.ours || match.theirs || match.base;
+	if (!entry) return null;
+	switch (entry.type) {
+		case "instance_entry":
+		case "schema_entry":
+		case "synthesis_entry":
+		case "actualize_entry": return entry.header.timestamp.value;
+		default: return null;
+	}
+}
+
+//#endregion
+export { buildMergedResult };
+//# sourceMappingURL=merge-result-builder.js.map

package/dist/merge/merge-result-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-result-builder.js","names":["lines: string[]","stats: MergeStats"],"sources":["../../src/merge/merge-result-builder.ts"],"sourcesContent":["import type { EntryMatch } from \"./entry-matcher.js\";\nimport type { MergeConflict } from \"./conflict-detector.js\";\nimport type { MergeOptions } from \"./driver.js\";\nimport { formatConflict, formatEntry } from \"./conflict-formatter.js\";\nimport { mergeEntry, entriesEqual } from \"./entry-merger.js\";\nimport { serializeIdentity } from \"./entry-matcher.js\";\n\n/**\n * Statistics about a merge operation\n */\nexport interface MergeStats {\n  /**\n   * Total entries in merged result\n   */\n  totalEntries: number;\n\n  /**\n   * Entries present only in ours (additions)\n   */\n  oursOnly: number;\n\n  /**\n   * Entries present only in theirs (additions)\n   */\n  theirsOnly: number;\n\n  /**\n   * Entries present in all three versions unchanged\n   */\n  common: number;\n\n  /**\n   * Entries successfully auto-merged\n   */\n  autoMerged: number;\n\n  /**\n   * Number of conflicts detected\n   */\n  conflicts: number;\n}\n\n/**\n * Result of a three-way merge operation\n */\nexport interface MergeResult {\n  /**\n   * Whether the merge completed without conflicts\n   * - `true`: Clean merge, all changes reconciled\n   * - `false`: Conflicts detected, manual resolution required\n   */\n  success: boolean;\n\n  /**\n   * The merged content as a string\n   * - On success: Clean merged entries\n   * - On failure: Includes conflict markers\n   */\n  content: string;\n\n  /**\n   * List of conflicts detected during merge\n   * Empty array if success is true\n   */\n  conflicts: MergeConflict[];\n\n  /**\n   * Statistics about the merge operation\n   */\n  stats: MergeStats;\n}\n\n/**\n * Build the final merged result from matches and conflicts\n *\n * @param matches - Array of matched entry triplets\n * @param conflicts - Array of detected conflicts\n * @param options - Merge options\n * @returns Complete merge result with content and statistics\n */\nexport function buildMergedResult(\n  matches: EntryMatch[],\n  conflicts: MergeConflict[],\n  options: MergeOptions = {},\n): MergeResult {\n  const conflictMap = new Map<string, MergeConflict>();\n  for (const conflict of conflicts) {\n    const key = serializeIdentity(conflict.identity);\n    conflictMap.set(key, conflict);\n  }\n\n  const lines: string[] = [];\n  const stats: MergeStats = {\n    totalEntries: 0,\n    oursOnly: 0,\n    theirsOnly: 0,\n    common: 0,\n    autoMerged: 0,\n    conflicts: conflicts.length,\n  };\n\n  const sortedMatches = sortMatchesByTimestamp(matches);\n\n  for (const match of sortedMatches) {\n    const matchKey = serializeIdentity(match.identity);\n    const conflict = conflictMap.get(matchKey);\n\n    if (conflict) {\n      const conflictLines = formatConflict(conflict, options);\n      conflict.location = lines.length + 1;\n      lines.push(...conflictLines);\n      lines.push(\"\");\n    } else {\n      const merged = mergeEntry(match);\n      if (merged) {\n        lines.push(...formatEntry(merged));\n        lines.push(\"\");\n\n        stats.totalEntries++;\n        if (!match.base && match.ours && !match.theirs) {\n          stats.oursOnly++;\n        } else if (!match.base && !match.ours && match.theirs) {\n          stats.theirsOnly++;\n        } else if (match.base && match.ours && match.theirs) {\n          if (entriesEqual(match.base, match.ours) && entriesEqual(match.base, match.theirs)) {\n            stats.common++;\n          } else {\n            stats.autoMerged++;\n          }\n        }\n      }\n    }\n  }\n\n  if (lines.length > 0 && lines[lines.length - 1] === \"\") {\n    lines.pop();\n  }\n\n  return {\n    success: conflicts.length === 0,\n    content: lines.join(\"\\n\"),\n    conflicts,\n    stats,\n  };\n}\n\n/**\n * Sort matches by timestamp for chronological output\n */\nfunction sortMatchesByTimestamp(matches: EntryMatch[]): EntryMatch[] {\n  return [...matches].sort((a, b) => {\n    const tsA = getMatchTimestamp(a);\n    const tsB = getMatchTimestamp(b);\n\n    if (!tsA && !tsB) {\n      return 0;\n    }\n    if (!tsA) {\n      return 1;\n    }\n    if (!tsB) {\n      return -1;\n    }\n\n    return tsA.localeCompare(tsB);\n  });\n}\n\n/**\n * Get timestamp from a match (prefer ours, then theirs, then base)\n */\nfunction getMatchTimestamp(match: EntryMatch): string | null {\n  const entry = match.ours || match.theirs || match.base;\n  if (!entry) {\n    return null;\n  }\n\n  switch (entry.type) {\n    case \"instance_entry\":\n    case \"schema_entry\":\n    case \"synthesis_entry\":\n    case \"actualize_entry\":\n      return entry.header.timestamp.value;\n    default:\n      return null;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAgFA,SAAgB,kBACd,SACA,WACA,UAAwB,EAAE,EACb;CACb,MAAM,8BAAc,IAAI,KAA4B;AACpD,MAAK,MAAM,YAAY,WAAW;EAChC,MAAM,MAAM,kBAAkB,SAAS,SAAS;AAChD,cAAY,IAAI,KAAK,SAAS;;CAGhC,MAAMA,QAAkB,EAAE;CAC1B,MAAMC,QAAoB;EACxB,cAAc;EACd,UAAU;EACV,YAAY;EACZ,QAAQ;EACR,YAAY;EACZ,WAAW,UAAU;EACtB;CAED,MAAM,gBAAgB,uBAAuB,QAAQ;AAErD,MAAK,MAAM,SAAS,eAAe;EACjC,MAAM,WAAW,kBAAkB,MAAM,SAAS;EAClD,MAAM,WAAW,YAAY,IAAI,SAAS;AAE1C,MAAI,UAAU;GACZ,MAAM,gBAAgB,eAAe,UAAU,QAAQ;AACvD,YAAS,WAAW,MAAM,SAAS;AACnC,SAAM,KAAK,GAAG,cAAc;AAC5B,SAAM,KAAK,GAAG;SACT;GACL,MAAM,SAAS,WAAW,MAAM;AAChC,OAAI,QAAQ;AACV,UAAM,KAAK,GAAG,YAAY,OAAO,CAAC;AAClC,UAAM,KAAK,GAAG;AAEd,UAAM;AACN,QAAI,CAAC,MAAM,QAAQ,MAAM,QAAQ,CAAC,MAAM,OACtC,OAAM;aACG,CAAC,MAAM,QAAQ,CAAC,MAAM,QAAQ,MAAM,OAC7C,OAAM;aACG,MAAM,QAAQ,MAAM,QAAQ,MAAM,OAC3C,KAAI,aAAa,MAAM,MAAM,MAAM,KAAK,IAAI,aAAa,MAAM,MAAM,MAAM,OAAO,CAChF,OAAM;QAEN,OAAM;;;;AAOhB,KAAI,MAAM,SAAS,KAAK,MAAM,MAAM,SAAS,OAAO,GAClD,OAAM,KAAK;AAGb,QAAO;EACL,SAAS,UAAU,WAAW;EAC9B,SAAS,MAAM,KAAK,KAAK;EACzB;EACA;EACD;;;;;AAMH,SAAS,uBAAuB,SAAqC;AACnE,QAAO,CAAC,GAAG,QAAQ,CAAC,MAAM,GAAG,MAAM;EACjC,MAAM,MAAM,kBAAkB,EAAE;EAChC,MAAM,MAAM,kBAAkB,EAAE;AAEhC,MAAI,CAAC,OAAO,CAAC,IACX,QAAO;AAET,MAAI,CAAC,IACH,QAAO;AAET,MAAI,CAAC,IACH,QAAO;AAGT,SAAO,IAAI,cAAc,IAAI;GAC7B;;;;;AAMJ,SAAS,kBAAkB,OAAkC;CAC3D,MAAM,QAAQ,MAAM,QAAQ,MAAM,UAAU,MAAM;AAClD,KAAI,CAAC,MACH,QAAO;AAGT,SAAQ,MAAM,MAAd;EACE,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,kBACH,QAAO,MAAM,OAAO,UAAU;EAChC,QACE,QAAO"}

package/dist/mod.d.ts

@@ -0,0 +1,31 @@
+import { ActualizeEntry, Entry, InstanceEntry, Location, Query, QueryCondition, SchemaEntry, SynthesisEntry, Timestamp, isSyntaxError } from "./ast/ast-types.js";
+import { BlockMatch, Position as Position$1, SourceMap } from "./source-map.js";
+import { FileType, GenericTree, ParseOptions, ParsedBlock, ParsedDocument, ThaloParser } from "./parser.shared.js";
+import { LinkDefinition, LinkIndex, LinkReference, SemanticModel, SemanticModelDirtyFlags, SemanticUpdateResult } from "./semantic/analyzer.js";
+import { EntitySchema, FieldSchema, SectionSchema, TypeExpr } from "./schema/registry.js";
+import { Position } from "./model/line-index.js";
+import { DocumentBlock, EditRange, EditResult } from "./model/document.js";
+import { InvalidationResult, ModelDefaultValue, ModelFieldDefinition, ModelSchemaEntry, ModelSectionDefinition, ModelTypeExpression, Workspace } from "./model/workspace.js";
+import { FieldCondition, LinkCondition, Query as Query$1, QueryCondition as QueryCondition$1, QueryOptions, TagCondition, astQueryToModelQuery, entryMatchesQuery, executeQueries, executeQuery, formatQuery, parseQueryString, validateQueryEntities } from "./services/query.js";
+import { ChangeMarker, ChangeTracker, parseCheckpoint } from "./services/change-tracker/change-tracker.js";
+import { ActualizeEntryInfo, ActualizeResult, DEFAULT_INSTRUCTIONS_TEMPLATE, InstructionsParams, RunActualizeOptions, SynthesisOutputInfo, generateInstructions, generateTimestamp, runActualize } from "./commands/actualize.js";
+import { RULE_CATEGORIES, Rule, RuleCategory, Severity, allRules } from "./checker/rules/rules.js";
+import { CheckConfig, Diagnostic, checkDocument } from "./checker/check.js";
+import { CheckResult, DiagnosticInfo, DiagnosticSeverity, RunCheckOptions, runCheck } from "./commands/check.js";
+import { FormatFileInput, FormatFileResult, FormatResult, Formatter, RunFormatOptions, SyntaxErrorInfo, runFormat } from "./commands/format.js";
+import { CheckpointError, QueriesResult, QueryConditionInfo, QueryEntryInfo, QueryResult, QueryValidationError, RunQueryOptions, isCheckpointError, isQueriesSuccess, isQueryError, isQuerySuccess, isQueryValidationError, runQueries, runQuery } from "./commands/query.js";
+import { DiagnosticFormat, formatDiagnostic, formatQueryResultRaw, formatTimestamp } from "./formatters.js";
+import { FragmentType, ParsedFragment } from "./fragment.js";
+import { DirectiveContext, EntityContext, FieldNameContext, LinkContext, MetadataKeyContext, NodeContext, SchemaEntityContext, SectionHeaderContext, SectionNameContext, TagContext, TimestampContext, TitleContext, TypeContext, UnknownContext, findNodeAtPosition } from "./ast/node-at-position.js";
+import { DefinitionResult, findDefinition, findDefinitionAtPosition } from "./services/definition.js";
+import { ReferenceLocation, ReferencesResult, findReferences, findReferencesAtPosition } from "./services/references.js";
+import { SemanticToken, TokenModifier, TokenType, encodeSemanticTokens, extractSemanticTokens, tokenModifiers, tokenTypes } from "./services/semantic-tokens.js";
+import { EntityDefinitionResult, EntityReferenceLocation, EntityReferencesResult, FieldDefinitionResult, FieldReferenceLocation, FieldReferencesResult, SectionDefinitionResult, SectionReferenceLocation, SectionReferencesResult, TagReferenceLocation, TagReferencesResult, findEntityDefinition, findEntityReferences, findFieldDefinition, findFieldReferences, findSectionDefinition, findSectionReferences, findTagReferences } from "./services/entity-navigation.js";
+import { HoverResult, formatActualizeEntry, formatEntitySchema, formatEntryHover, formatFieldHover, formatInstanceEntry, formatSchemaEntry, formatSectionHover, formatSynthesisEntry, formatTagHover, formatTimestampHover, getDirectiveDocumentation, getHoverInfo, getPrimitiveTypeDocumentation } from "./services/hover.js";
+import { ActualizeInfo, SynthesisInfo, findAllSyntheses, findEntryFile, findLatestActualize, getActualizeUpdatedTimestamp, getEntrySourceText, getSynthesisPrompt, getSynthesisSources } from "./services/synthesis.js";
+import { EntryIdentity, EntryMatch } from "./merge/entry-matcher.js";
+import { ConflictContext, ConflictRule, ConflictType, MergeConflict } from "./merge/conflict-detector.js";
+import { MergeResult, MergeStats } from "./merge/merge-result-builder.js";
+import { MergeOptions, mergeThaloFiles } from "./merge/driver.js";
+import { ALL_DIRECTIVES, Directive, INSTANCE_DIRECTIVES, InstanceDirective, PRIMITIVE_TYPES, PrimitiveType, SCHEMA_BLOCK_HEADERS, SCHEMA_DIRECTIVES, SYNTHESIS_DIRECTIVES, SchemaBlockHeader, SchemaDirective, SynthesisDirective, isDirective, isInstanceDirective, isPrimitiveType, isSchemaDirective, isSynthesisDirective } from "./constants.js";
+export { ALL_DIRECTIVES, type ActualizeEntry, type ActualizeEntryInfo, ActualizeInfo, type ActualizeResult, type Query as AstQuery, type QueryCondition as AstQueryCondition, type BlockMatch, type ChangeMarker, type ChangeTracker, type CheckConfig, type CheckResult, type CheckpointError, type ConflictContext, type ConflictRule, type ConflictType, DEFAULT_INSTRUCTIONS_TEMPLATE, DefinitionResult, type Diagnostic, type DiagnosticFormat, type DiagnosticInfo, type DiagnosticSeverity, Directive, type DirectiveContext, type DocumentBlock, type EditRange, type EditResult, type EntityContext, EntityDefinitionResult, EntityReferenceLocation, EntityReferencesResult, type EntitySchema, type Entry, type EntryIdentity, type EntryMatch, type FieldCondition, FieldDefinitionResult, type FieldNameContext, FieldReferenceLocation, FieldReferencesResult, type FieldSchema, type FileType, type FormatFileInput, type FormatFileResult, type FormatResult, type Formatter, type FragmentType, type GenericTree, HoverResult, INSTANCE_DIRECTIVES, InstanceDirective, type InstanceEntry, type InstructionsParams, type InvalidationResult, type Position as LinePosition, type LinkCondition, type LinkContext, type LinkDefinition, type LinkIndex, type LinkReference, type Location, type MergeConflict, type MergeOptions, type MergeResult, type MergeStats, type MetadataKeyContext, type ModelDefaultValue, type ModelFieldDefinition, type ModelSchemaEntry, type ModelSectionDefinition, type ModelTypeExpression, type NodeContext, PRIMITIVE_TYPES, type ParseOptions, type ParsedBlock, type ParsedDocument, type ParsedFragment, type Position$1 as Position, PrimitiveType, type QueriesResult, type Query$1 as Query, type QueryCondition$1 as QueryCondition, type QueryConditionInfo, type QueryEntryInfo, QueryOptions, type QueryResult, type QueryValidationError, RULE_CATEGORIES, ReferenceLocation, ReferencesResult, type Rule, type RuleCategory, type RunActualizeOptions, type RunCheckOptions, type RunFormatOptions, type RunQueryOptions, SCHEMA_BLOCK_HEADERS, SCHEMA_DIRECTIVES, SYNTHESIS_DIRECTIVES, SchemaBlockHeader, SchemaDirective, type SchemaEntityContext, type SchemaEntry, SectionDefinitionResult, type SectionHeaderContext, type SectionNameContext, SectionReferenceLocation, SectionReferencesResult, type SectionSchema, type SemanticModel, type SemanticModelDirtyFlags, type SemanticToken, type SemanticUpdateResult, type Severity, type SourceMap, type SyntaxErrorInfo, SynthesisDirective, type SynthesisEntry, SynthesisInfo, type SynthesisOutputInfo, type TagCondition, type TagContext, TagReferenceLocation, TagReferencesResult, type ThaloParser, type Timestamp, type TimestampContext, type TitleContext, type TokenModifier, type TokenType, type TypeContext, TypeExpr, type UnknownContext, Workspace, allRules, astQueryToModelQuery, checkDocument, encodeSemanticTokens, entryMatchesQuery, executeQueries, executeQuery, extractSemanticTokens, findAllSyntheses, findDefinition, findDefinitionAtPosition, findEntityDefinition, findEntityReferences, findEntryFile, findFieldDefinition, findFieldReferences, findLatestActualize, findNodeAtPosition, findReferences, findReferencesAtPosition, findSectionDefinition, findSectionReferences, findTagReferences, formatActualizeEntry, formatDiagnostic, formatEntitySchema, formatEntryHover, formatFieldHover, formatInstanceEntry, formatQuery, formatQueryResultRaw, formatSchemaEntry, formatSectionHover, formatSynthesisEntry, formatTagHover, formatTimestamp, formatTimestampHover, generateInstructions, generateTimestamp, getActualizeUpdatedTimestamp, getDirectiveDocumentation, getEntrySourceText, getHoverInfo, getPrimitiveTypeDocumentation, getSynthesisPrompt, getSynthesisSources, isCheckpointError, isDirective, isInstanceDirective, isPrimitiveType, isQueriesSuccess, isQueryError, isQuerySuccess, isQueryValidationError, isSchemaDirective, isSyntaxError, isSynthesisDirective, mergeThaloFiles, parseCheckpoint, parseQueryString, runActualize, runCheck, runFormat, runQueries, runQuery, tokenModifiers, tokenTypes, validateQueryEntities };

package/dist/mod.js

@@ -0,0 +1,23 @@
+import { astQueryToModelQuery, entryMatchesQuery, executeQueries, executeQuery, formatQuery, parseQueryString, validateQueryEntities } from "./services/query.js";
+import { parseCheckpoint } from "./services/change-tracker/change-tracker.js";
+import { isSyntaxError } from "./ast/ast-types.js";
+import { formatDiagnostic, formatQueryResultRaw, formatTimestamp } from "./formatters.js";
+import { TypeExpr } from "./schema/registry.js";
+import { Workspace } from "./model/workspace.js";
+import { findNodeAtPosition } from "./ast/node-at-position.js";
+import { RULE_CATEGORIES, allRules } from "./checker/rules/rules.js";
+import { checkDocument } from "./checker/check.js";
+import { findDefinition, findDefinitionAtPosition } from "./services/definition.js";
+import { findReferences, findReferencesAtPosition } from "./services/references.js";
+import { encodeSemanticTokens, extractSemanticTokens, tokenModifiers, tokenTypes } from "./services/semantic-tokens.js";
+import { findEntityDefinition, findEntityReferences, findFieldDefinition, findFieldReferences, findSectionDefinition, findSectionReferences, findTagReferences } from "./services/entity-navigation.js";
+import { formatActualizeEntry, formatEntitySchema, formatEntryHover, formatFieldHover, formatInstanceEntry, formatSchemaEntry, formatSectionHover, formatSynthesisEntry, formatTagHover, formatTimestampHover, getDirectiveDocumentation, getHoverInfo, getPrimitiveTypeDocumentation } from "./services/hover.js";
+import { findAllSyntheses, findEntryFile, findLatestActualize, getActualizeUpdatedTimestamp, getEntrySourceText, getSynthesisPrompt, getSynthesisSources } from "./services/synthesis.js";
+import { mergeThaloFiles } from "./merge/driver.js";
+import { ALL_DIRECTIVES, INSTANCE_DIRECTIVES, PRIMITIVE_TYPES, SCHEMA_BLOCK_HEADERS, SCHEMA_DIRECTIVES, SYNTHESIS_DIRECTIVES, isDirective, isInstanceDirective, isPrimitiveType, isSchemaDirective, isSynthesisDirective } from "./constants.js";
+import { runCheck } from "./commands/check.js";
+import { runFormat } from "./commands/format.js";
+import { isCheckpointError, isQueriesSuccess, isQueryError, isQuerySuccess, isQueryValidationError, runQueries, runQuery } from "./commands/query.js";
+import { DEFAULT_INSTRUCTIONS_TEMPLATE, generateInstructions, generateTimestamp, runActualize } from "./commands/actualize.js";
+
+export { ALL_DIRECTIVES, DEFAULT_INSTRUCTIONS_TEMPLATE, INSTANCE_DIRECTIVES, PRIMITIVE_TYPES, RULE_CATEGORIES, SCHEMA_BLOCK_HEADERS, SCHEMA_DIRECTIVES, SYNTHESIS_DIRECTIVES, TypeExpr, Workspace, allRules, astQueryToModelQuery, checkDocument, encodeSemanticTokens, entryMatchesQuery, executeQueries, executeQuery, extractSemanticTokens, findAllSyntheses, findDefinition, findDefinitionAtPosition, findEntityDefinition, findEntityReferences, findEntryFile, findFieldDefinition, findFieldReferences, findLatestActualize, findNodeAtPosition, findReferences, findReferencesAtPosition, findSectionDefinition, findSectionReferences, findTagReferences, formatActualizeEntry, formatDiagnostic, formatEntitySchema, formatEntryHover, formatFieldHover, formatInstanceEntry, formatQuery, formatQueryResultRaw, formatSchemaEntry, formatSectionHover, formatSynthesisEntry, formatTagHover, formatTimestamp, formatTimestampHover, generateInstructions, generateTimestamp, getActualizeUpdatedTimestamp, getDirectiveDocumentation, getEntrySourceText, getHoverInfo, getPrimitiveTypeDocumentation, getSynthesisPrompt, getSynthesisSources, isCheckpointError, isDirective, isInstanceDirective, isPrimitiveType, isQueriesSuccess, isQueryError, isQuerySuccess, isQueryValidationError, isSchemaDirective, isSyntaxError, isSynthesisDirective, mergeThaloFiles, parseCheckpoint, parseQueryString, runActualize, runCheck, runFormat, runQueries, runQuery, tokenModifiers, tokenTypes, validateQueryEntities };

package/dist/model/document.d.ts

@@ -0,0 +1,134 @@
+import { SourceMap } from "../source-map.js";
+import { FileType, GenericTree, ThaloParser } from "../parser.shared.js";
+import { LineIndex } from "./line-index.js";
+
+//#region src/model/document.d.ts
+/** Position type compatible with tree-sitter Point */
+interface Point {
+  row: number;
+  column: number;
+}
+/**
+ * Edit range for applying incremental edits to a document.
+ * Uses tree-sitter's edit format.
+ */
+interface EditRange {
+  startIndex: number;
+  startPosition: Point;
+  oldEndIndex: number;
+  oldEndPosition: Point;
+  newEndIndex: number;
+  newEndPosition: Point;
+}
+/**
+ * A parsed thalo block within a document.
+ */
+interface DocumentBlock<T extends GenericTree = GenericTree> {
+  /** The thalo source code for this block */
+  source: string;
+  /** Source map for translating block-relative positions to file-absolute positions */
+  sourceMap: SourceMap;
+  /** The parsed tree-sitter tree */
+  tree: T;
+  /** Character offset where this block starts in the full document */
+  startOffset: number;
+  /** Character offset where this block ends in the full document */
+  endOffset: number;
+}
+/**
+ * Result of applying an edit to a document.
+ */
+interface EditResult {
+  /** Whether the edit affected thalo block boundaries (```thalo fences) */
+  blockBoundariesChanged: boolean;
+  /** Indices of blocks that were modified */
+  modifiedBlockIndices: number[];
+  /** Whether a full reparse was required */
+  fullReparse: boolean;
+}
+/**
+ * A Document owns the source text and Tree-sitter tree(s) for a file,
+ * providing efficient incremental edit operations.
+ *
+ * The Document is parser-agnostic - it accepts any parser that implements
+ * the ThaloParser interface.
+ */
+declare class Document<T extends GenericTree = GenericTree> {
+  readonly filename: string;
+  readonly fileType: FileType;
+  private parser;
+  private _source;
+  private _blocks;
+  private _lineIndex;
+  /**
+   * Create a Document with a parser.
+   *
+   * @param parser - A ThaloParser instance
+   * @param filename - The filename for this document
+   * @param source - The source code
+   * @param fileType - Optional explicit file type
+   */
+  constructor(parser: ThaloParser<T>, filename: string, source: string, fileType?: FileType);
+  /**
+   * Get the current source text.
+   */
+  get source(): string;
+  /**
+   * Get the line index for position conversions.
+   */
+  get lineIndex(): LineIndex;
+  /**
+   * Get the current parsed blocks.
+   */
+  get blocks(): readonly DocumentBlock<T>[];
+  /**
+   * Apply an incremental edit to the document.
+   *
+   * @param startLine - 0-based start line of the edit
+   * @param startColumn - 0-based start column of the edit
+   * @param endLine - 0-based end line of the edit (exclusive)
+   * @param endColumn - 0-based end column of the edit
+   * @param newText - The replacement text
+   * @returns Information about what changed
+   */
+  applyEdit(startLine: number, startColumn: number, endLine: number, endColumn: number, newText: string): EditResult;
+  /**
+   * Apply an edit using raw edit parameters (tree-sitter format).
+   */
+  applyEditRange(edit: EditRange, newText: string): EditResult;
+  /**
+   * Replace the entire document content (for full sync).
+   */
+  replaceContent(newSource: string): void;
+  /**
+   * Detect file type from filename extension or content.
+   */
+  private static detectFileType;
+  /**
+   * Parse all thalo blocks from the source.
+   */
+  private parseBlocks;
+  /**
+   * Check if an edit might affect thalo block boundaries (```thalo fences).
+   */
+  private mightAffectBlockBoundaries;
+  /**
+   * Apply incremental edit to a thalo file (single block).
+   */
+  private applyIncrementalEdit;
+  /**
+   * Apply edit to a markdown file, updating affected blocks incrementally.
+   */
+  private applyMarkdownEdit;
+  /**
+   * Update block offsets after an edit outside all blocks.
+   */
+  private updateBlockOffsets;
+  /**
+   * Update a single block using incremental parsing.
+   */
+  private updateSingleBlockIncremental;
+}
+//#endregion
+export { Document, DocumentBlock, EditRange, EditResult };
+//# sourceMappingURL=document.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"document.d.ts","names":[],"sources":["../../src/model/document.ts"],"sourcesContent":[],"mappings":";;;;;;UAMU,KAAA;EAAA,GAAA,EAAA,MAAK;EASE,MAAA,EAAA,MAAS;;;;;AAY1B;AAAyC,UAZxB,SAAA,CAYwB;EAAc,UAAA,EAAA,MAAA;EAI1C,aAAA,EAdI,KAcJ;EAEL,WAAA,EAAA,MAAA;EAAC,cAAA,EAdS,KAcT;EAUQ,WAAA,EAAU,MAAA;EAsBd,cAAQ,EA5CH,KA4CG;;;;;AAiBC,UAvDL,aAuDK,CAAA,UAvDmB,WAuDnB,GAvDiC,WAuDjC,CAAA,CAAA;EAA6D;EAmBhE,MAAA,EAAA,MAAA;EAOoB;EAAd,SAAA,EA7EZ,SA6EY;EAoBpB;EAwCkB,IAAA,EAvIf,CAuIe;EAA6B;EAAU,WAAA,EAAA,MAAA;;;;;;;UA7H7C,UAAA;;;;;;;;;;;;;;;cAsBJ,mBAAmB,cAAc;;qBAEzB;;;;;;;;;;;;;sBAeC,YAAY,iDAAiD;;;;;;;;mBAmBhE;;;;yBAOM,cAAc;;;;;;;;;;;0GAoBlC;;;;uBAwCkB,6BAA6B"}

package/dist/model/document.js

@@ -0,0 +1,275 @@
+import { createSourceMap, identitySourceMap } from "../source-map.js";
+import { LineIndex, computeEdit } from "./line-index.js";
+
+//#region src/model/document.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;
+/**
+* A Document owns the source text and Tree-sitter tree(s) for a file,
+* providing efficient incremental edit operations.
+*
+* The Document is parser-agnostic - it accepts any parser that implements
+* the ThaloParser interface.
+*/
+var Document = class Document {
+	filename;
+	fileType;
+	parser;
+	_source;
+	_blocks;
+	_lineIndex;
+	/**
+	* Create a Document with a parser.
+	*
+	* @param parser - A ThaloParser instance
+	* @param filename - The filename for this document
+	* @param source - The source code
+	* @param fileType - Optional explicit file type
+	*/
+	constructor(parser, filename, source, fileType) {
+		this.parser = parser;
+		this.filename = filename;
+		this._source = source;
+		this.fileType = fileType ?? Document.detectFileType(filename, source);
+		this._lineIndex = new LineIndex(this._source);
+		this._blocks = this.parseBlocks(this._source);
+	}
+	/**
+	* Get the current source text.
+	*/
+	get source() {
+		return this._source;
+	}
+	/**
+	* Get the line index for position conversions.
+	*/
+	get lineIndex() {
+		return this._lineIndex;
+	}
+	/**
+	* Get the current parsed blocks.
+	*/
+	get blocks() {
+		return this._blocks;
+	}
+	/**
+	* Apply an incremental edit to the document.
+	*
+	* @param startLine - 0-based start line of the edit
+	* @param startColumn - 0-based start column of the edit
+	* @param endLine - 0-based end line of the edit (exclusive)
+	* @param endColumn - 0-based end column of the edit
+	* @param newText - The replacement text
+	* @returns Information about what changed
+	*/
+	applyEdit(startLine, startColumn, endLine, endColumn, newText) {
+		const edit = computeEdit(this._lineIndex, startLine, startColumn, endLine, endColumn, newText);
+		const newSource = this._source.slice(0, edit.startIndex) + newText + this._source.slice(edit.oldEndIndex);
+		const blockBoundariesChanged = this.fileType === "markdown" && this.mightAffectBlockBoundaries(edit, newText);
+		const oldSource = this._source;
+		this._source = newSource;
+		this._lineIndex = new LineIndex(newSource);
+		if (blockBoundariesChanged) {
+			this._blocks = this.parseBlocks(newSource);
+			return {
+				blockBoundariesChanged: true,
+				modifiedBlockIndices: this._blocks.map((_, i) => i),
+				fullReparse: true
+			};
+		}
+		if (this.fileType === "thalo") return this.applyIncrementalEdit(edit, oldSource, newSource, newText);
+		else return this.applyMarkdownEdit(edit, oldSource, newSource, newText);
+	}
+	/**
+	* Apply an edit using raw edit parameters (tree-sitter format).
+	*/
+	applyEditRange(edit, newText) {
+		const startPos = this._lineIndex.offsetToPosition(edit.startIndex);
+		const endPos = this._lineIndex.offsetToPosition(edit.oldEndIndex);
+		return this.applyEdit(startPos.line, startPos.column, endPos.line, endPos.column, newText);
+	}
+	/**
+	* Replace the entire document content (for full sync).
+	*/
+	replaceContent(newSource) {
+		this._source = newSource;
+		this._lineIndex = new LineIndex(newSource);
+		this._blocks = this.parseBlocks(newSource);
+	}
+	/**
+	* Detect file type from filename extension or content.
+	*/
+	static detectFileType(filename, source) {
+		if (filename.endsWith(".thalo")) return "thalo";
+		if (filename.endsWith(".md")) return "markdown";
+		if (source.includes("```thalo")) return "markdown";
+		return "thalo";
+	}
+	/**
+	* Parse all thalo blocks from the source.
+	*/
+	parseBlocks(source) {
+		if (this.fileType === "thalo") {
+			const tree = this.parser.parse(source);
+			return [{
+				source,
+				sourceMap: identitySourceMap(),
+				tree,
+				startOffset: 0,
+				endOffset: source.length
+			}];
+		}
+		const blocks = [];
+		let match;
+		while ((match = THALO_FENCE_REGEX.exec(source)) !== null) {
+			const content = match[1];
+			const contentStart = match.index + match[0].indexOf(content);
+			const sourceMap = createSourceMap(source, contentStart, content);
+			const tree = this.parser.parse(content);
+			blocks.push({
+				source: content,
+				sourceMap,
+				tree,
+				startOffset: contentStart,
+				endOffset: contentStart + content.length
+			});
+		}
+		THALO_FENCE_REGEX.lastIndex = 0;
+		return blocks;
+	}
+	/**
+	* Check if an edit might affect thalo block boundaries (```thalo fences).
+	*/
+	mightAffectBlockBoundaries(edit, newText) {
+		const hasFenceInOld = this._source.slice(edit.startIndex, edit.oldEndIndex).includes("```");
+		const hasFenceInNew = newText.includes("```");
+		if (hasFenceInOld || hasFenceInNew) return true;
+		for (const block of this._blocks) {
+			const fenceStartOffset = block.startOffset - 9;
+			if (fenceStartOffset >= edit.startIndex && fenceStartOffset < edit.oldEndIndex) return true;
+			const fenceEndOffset = block.endOffset;
+			if (fenceEndOffset >= edit.startIndex && fenceEndOffset < edit.oldEndIndex) return true;
+		}
+		return false;
+	}
+	/**
+	* Apply incremental edit to a thalo file (single block).
+	*/
+	applyIncrementalEdit(edit, _oldSource, newSource, _newText) {
+		const block = this._blocks[0];
+		block.tree.edit({
+			startIndex: edit.startIndex,
+			oldEndIndex: edit.oldEndIndex,
+			newEndIndex: edit.newEndIndex,
+			startPosition: edit.startPosition,
+			oldEndPosition: edit.oldEndPosition,
+			newEndPosition: edit.newEndPosition
+		});
+		const newTree = this.parser.parseIncremental(newSource, block.tree);
+		this._blocks = [{
+			source: newSource,
+			sourceMap: identitySourceMap(),
+			tree: newTree,
+			startOffset: 0,
+			endOffset: newSource.length
+		}];
+		return {
+			blockBoundariesChanged: false,
+			modifiedBlockIndices: [0],
+			fullReparse: false
+		};
+	}
+	/**
+	* Apply edit to a markdown file, updating affected blocks incrementally.
+	*/
+	applyMarkdownEdit(edit, _oldSource, newSource, _newText) {
+		const affectedBlockIndices = [];
+		for (let i = 0; i < this._blocks.length; i++) {
+			const block = this._blocks[i];
+			if (edit.startIndex < block.endOffset && edit.oldEndIndex > block.startOffset) affectedBlockIndices.push(i);
+		}
+		if (affectedBlockIndices.length === 0) {
+			this.updateBlockOffsets(edit, newSource);
+			return {
+				blockBoundariesChanged: false,
+				modifiedBlockIndices: [],
+				fullReparse: false
+			};
+		}
+		if (affectedBlockIndices.length === 1) {
+			const blockIndex = affectedBlockIndices[0];
+			this.updateSingleBlockIncremental(blockIndex, edit, newSource);
+			return {
+				blockBoundariesChanged: false,
+				modifiedBlockIndices: affectedBlockIndices,
+				fullReparse: false
+			};
+		}
+		this._blocks = this.parseBlocks(newSource);
+		return {
+			blockBoundariesChanged: false,
+			modifiedBlockIndices: this._blocks.map((_, i) => i),
+			fullReparse: true
+		};
+	}
+	/**
+	* Update block offsets after an edit outside all blocks.
+	*/
+	updateBlockOffsets(edit, newSource) {
+		const delta = edit.newEndIndex - edit.oldEndIndex;
+		this._blocks = this._blocks.map((block) => {
+			if (block.startOffset > edit.oldEndIndex) return {
+				...block,
+				startOffset: block.startOffset + delta,
+				endOffset: block.endOffset + delta,
+				sourceMap: createSourceMap(newSource, block.startOffset + delta, block.source)
+			};
+			return block;
+		});
+	}
+	/**
+	* Update a single block using incremental parsing.
+	*/
+	updateSingleBlockIncremental(blockIndex, edit, newSource) {
+		const oldBlock = this._blocks[blockIndex];
+		const blockRelativeStartIndex = edit.startIndex - oldBlock.startOffset;
+		const blockRelativeOldEndIndex = edit.oldEndIndex - oldBlock.startOffset;
+		const delta = edit.newEndIndex - edit.oldEndIndex;
+		const newBlockEndOffset = oldBlock.endOffset + delta;
+		const newBlockSource = newSource.slice(oldBlock.startOffset, newBlockEndOffset);
+		const blockRelativeNewEndIndex = blockRelativeStartIndex + (edit.newEndIndex - edit.startIndex);
+		const blockRelativeEdit = computeEdit(new LineIndex(oldBlock.source), edit.startPosition.row - oldBlock.sourceMap.lineOffset, edit.startPosition.row === oldBlock.sourceMap.lineOffset ? edit.startPosition.column - oldBlock.sourceMap.columnOffset : edit.startPosition.column, edit.oldEndPosition.row - oldBlock.sourceMap.lineOffset, edit.oldEndPosition.row === oldBlock.sourceMap.lineOffset ? edit.oldEndPosition.column - oldBlock.sourceMap.columnOffset : edit.oldEndPosition.column, newSource.slice(edit.startIndex, edit.newEndIndex));
+		oldBlock.tree.edit({
+			startIndex: blockRelativeStartIndex,
+			oldEndIndex: blockRelativeOldEndIndex,
+			newEndIndex: blockRelativeNewEndIndex,
+			startPosition: blockRelativeEdit.startPosition,
+			oldEndPosition: blockRelativeEdit.oldEndPosition,
+			newEndPosition: blockRelativeEdit.newEndPosition
+		});
+		const newTree = this.parser.parseIncremental(newBlockSource, oldBlock.tree);
+		this._blocks = this._blocks.map((block, i) => {
+			if (i === blockIndex) return {
+				source: newBlockSource,
+				sourceMap: createSourceMap(newSource, oldBlock.startOffset, newBlockSource),
+				tree: newTree,
+				startOffset: oldBlock.startOffset,
+				endOffset: newBlockEndOffset
+			};
+			else if (i > blockIndex) return {
+				...block,
+				startOffset: block.startOffset + delta,
+				endOffset: block.endOffset + delta,
+				sourceMap: createSourceMap(newSource, block.startOffset + delta, block.source)
+			};
+			return block;
+		});
+	}
+};
+
+//#endregion
+export { Document };
+//# sourceMappingURL=document.js.map

package/dist/model/document.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.js","names":["blocks: DocumentBlock<T>[]","match: RegExpExecArray | null","affectedBlockIndices: number[]"],"sources":["../../src/model/document.ts"],"sourcesContent":["import type { SourceMap } from \"../source-map.js\";\nimport { createSourceMap, identitySourceMap } from \"../source-map.js\";\nimport type { ThaloParser, GenericTree, FileType } from \"../parser.shared.js\";\nimport { LineIndex, computeEdit } from \"./line-index.js\";\n\n/** Position type compatible with tree-sitter Point */\ninterface Point {\n  row: number;\n  column: number;\n}\n\n/**\n * Edit range for applying incremental edits to a document.\n * Uses tree-sitter's edit format.\n */\nexport interface EditRange {\n  startIndex: number;\n  startPosition: Point;\n  oldEndIndex: number;\n  oldEndPosition: Point;\n  newEndIndex: number;\n  newEndPosition: Point;\n}\n\n/**\n * A parsed thalo block within a document.\n */\nexport interface DocumentBlock<T extends GenericTree = GenericTree> {\n  /** The thalo source code for this block */\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  /** Character offset where this block starts in the full document */\n  startOffset: number;\n  /** Character offset where this block ends in the full document */\n  endOffset: number;\n}\n\n/**\n * Result of applying an edit to a document.\n */\nexport interface EditResult {\n  /** Whether the edit affected thalo block boundaries (```thalo fences) */\n  blockBoundariesChanged: boolean;\n  /** Indices of blocks that were modified */\n  modifiedBlockIndices: number[];\n  /** Whether a full reparse was required */\n  fullReparse: boolean;\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 * A Document owns the source text and Tree-sitter tree(s) for a file,\n * providing efficient incremental edit operations.\n *\n * The Document is parser-agnostic - it accepts any parser that implements\n * the ThaloParser interface.\n */\nexport class Document<T extends GenericTree = GenericTree> {\n  readonly filename: string;\n  readonly fileType: FileType;\n\n  private parser: ThaloParser<T>;\n  private _source: string;\n  private _blocks: DocumentBlock<T>[];\n  private _lineIndex: LineIndex;\n\n  /**\n   * Create a Document with a parser.\n   *\n   * @param parser - A ThaloParser instance\n   * @param filename - The filename for this document\n   * @param source - The source code\n   * @param fileType - Optional explicit file type\n   */\n  constructor(parser: ThaloParser<T>, filename: string, source: string, fileType?: FileType) {\n    this.parser = parser;\n    this.filename = filename;\n    this._source = source;\n    this.fileType = fileType ?? Document.detectFileType(filename, source);\n    this._lineIndex = new LineIndex(this._source);\n    this._blocks = this.parseBlocks(this._source);\n  }\n\n  /**\n   * Get the current source text.\n   */\n  get source(): string {\n    return this._source;\n  }\n\n  /**\n   * Get the line index for position conversions.\n   */\n  get lineIndex(): LineIndex {\n    return this._lineIndex;\n  }\n\n  /**\n   * Get the current parsed blocks.\n   */\n  get blocks(): readonly DocumentBlock<T>[] {\n    return this._blocks;\n  }\n\n  /**\n   * Apply an incremental edit to the document.\n   *\n   * @param startLine - 0-based start line of the edit\n   * @param startColumn - 0-based start column of the edit\n   * @param endLine - 0-based end line of the edit (exclusive)\n   * @param endColumn - 0-based end column of the edit\n   * @param newText - The replacement text\n   * @returns Information about what changed\n   */\n  applyEdit(\n    startLine: number,\n    startColumn: number,\n    endLine: number,\n    endColumn: number,\n    newText: string,\n  ): EditResult {\n    // Compute edit parameters\n    const edit = computeEdit(this._lineIndex, startLine, startColumn, endLine, endColumn, newText);\n\n    // Apply the edit to get new source\n    const newSource =\n      this._source.slice(0, edit.startIndex) + newText + this._source.slice(edit.oldEndIndex);\n\n    // Check if this is a markdown file and if block boundaries might have changed\n    const blockBoundariesChanged =\n      this.fileType === \"markdown\" && this.mightAffectBlockBoundaries(edit, newText);\n\n    // Update source and line index\n    const oldSource = this._source;\n    this._source = newSource;\n    this._lineIndex = new LineIndex(newSource);\n\n    // For markdown files with potential boundary changes, do a full reparse\n    if (blockBoundariesChanged) {\n      this._blocks = this.parseBlocks(newSource);\n      return {\n        blockBoundariesChanged: true,\n        modifiedBlockIndices: this._blocks.map((_, i) => i),\n        fullReparse: true,\n      };\n    }\n\n    // For thalo files or markdown edits within a single block, use incremental parsing\n    if (this.fileType === \"thalo\") {\n      // Single block, always incremental\n      return this.applyIncrementalEdit(edit, oldSource, newSource, newText);\n    } else {\n      // Markdown: find affected block(s)\n      return this.applyMarkdownEdit(edit, oldSource, newSource, newText);\n    }\n  }\n\n  /**\n   * Apply an edit using raw edit parameters (tree-sitter format).\n   */\n  applyEditRange(edit: EditRange, newText: string): EditResult {\n    const startPos = this._lineIndex.offsetToPosition(edit.startIndex);\n    const endPos = this._lineIndex.offsetToPosition(edit.oldEndIndex);\n    return this.applyEdit(startPos.line, startPos.column, endPos.line, endPos.column, newText);\n  }\n\n  /**\n   * Replace the entire document content (for full sync).\n   */\n  replaceContent(newSource: string): void {\n    this._source = newSource;\n    this._lineIndex = new LineIndex(newSource);\n    this._blocks = this.parseBlocks(newSource);\n  }\n\n  /**\n   * Detect file type from filename extension or content.\n   */\n  private static detectFileType(filename: string, source: string): FileType {\n    if (filename.endsWith(\".thalo\")) {\n      return \"thalo\";\n    }\n    if (filename.endsWith(\".md\")) {\n      return \"markdown\";\n    }\n    // Use heuristics: if it contains markdown thalo fences, treat as markdown\n    if (source.includes(\"```thalo\")) {\n      return \"markdown\";\n    }\n    return \"thalo\";\n  }\n\n  /**\n   * Parse all thalo blocks from the source.\n   */\n  private parseBlocks(source: string): DocumentBlock<T>[] {\n    if (this.fileType === \"thalo\") {\n      // Single block for pure thalo files\n      const tree = this.parser.parse(source);\n      return [\n        {\n          source,\n          sourceMap: identitySourceMap(),\n          tree,\n          startOffset: 0,\n          endOffset: source.length,\n        },\n      ];\n    }\n\n    // Extract thalo blocks from markdown\n    const blocks: DocumentBlock<T>[] = [];\n    let match: RegExpExecArray | null;\n\n    while ((match = THALO_FENCE_REGEX.exec(source)) !== null) {\n      const content = match[1];\n      const contentStart = match.index + match[0].indexOf(content);\n      const sourceMap = createSourceMap(source, contentStart, content);\n      const tree = this.parser.parse(content);\n\n      blocks.push({\n        source: content,\n        sourceMap,\n        tree,\n        startOffset: contentStart,\n        endOffset: contentStart + content.length,\n      });\n    }\n\n    // Reset regex state\n    THALO_FENCE_REGEX.lastIndex = 0;\n\n    return blocks;\n  }\n\n  /**\n   * Check if an edit might affect thalo block boundaries (```thalo fences).\n   */\n  private mightAffectBlockBoundaries(edit: EditRange, newText: string): boolean {\n    // Check if the edit region or new text contains fence markers\n    const oldText = this._source.slice(edit.startIndex, edit.oldEndIndex);\n    const hasFenceInOld = oldText.includes(\"```\");\n    const hasFenceInNew = newText.includes(\"```\");\n\n    if (hasFenceInOld || hasFenceInNew) {\n      return true;\n    }\n\n    // Check if any block boundary falls within the edit range\n    for (const block of this._blocks) {\n      // Check if fence start (```thalo) is in edit range\n      const fenceStartOffset = block.startOffset - \"```thalo\\n\".length;\n      if (fenceStartOffset >= edit.startIndex && fenceStartOffset < edit.oldEndIndex) {\n        return true;\n      }\n      // Check if fence end (```) is in edit range\n      const fenceEndOffset = block.endOffset;\n      if (fenceEndOffset >= edit.startIndex && fenceEndOffset < edit.oldEndIndex) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  /**\n   * Apply incremental edit to a thalo file (single block).\n   */\n  private applyIncrementalEdit(\n    edit: EditRange,\n    _oldSource: string,\n    newSource: string,\n    _newText: string,\n  ): EditResult {\n    const block = this._blocks[0];\n\n    // Tell tree-sitter about the edit\n    block.tree.edit({\n      startIndex: edit.startIndex,\n      oldEndIndex: edit.oldEndIndex,\n      newEndIndex: edit.newEndIndex,\n      startPosition: edit.startPosition,\n      oldEndPosition: edit.oldEndPosition,\n      newEndPosition: edit.newEndPosition,\n    });\n\n    // Reparse with the old tree for incremental parsing\n    const newTree = this.parser.parseIncremental(newSource, block.tree);\n\n    // Update the block\n    this._blocks = [\n      {\n        source: newSource,\n        sourceMap: identitySourceMap(),\n        tree: newTree,\n        startOffset: 0,\n        endOffset: newSource.length,\n      },\n    ];\n\n    return {\n      blockBoundariesChanged: false,\n      modifiedBlockIndices: [0],\n      fullReparse: false,\n    };\n  }\n\n  /**\n   * Apply edit to a markdown file, updating affected blocks incrementally.\n   */\n  private applyMarkdownEdit(\n    edit: EditRange,\n    _oldSource: string,\n    newSource: string,\n    _newText: string,\n  ): EditResult {\n    // Find which block(s) contain the edit\n    const affectedBlockIndices: number[] = [];\n\n    for (let i = 0; i < this._blocks.length; i++) {\n      const block = this._blocks[i];\n      // Check if edit overlaps with this block\n      if (edit.startIndex < block.endOffset && edit.oldEndIndex > block.startOffset) {\n        affectedBlockIndices.push(i);\n      }\n    }\n\n    if (affectedBlockIndices.length === 0) {\n      // Edit is outside all thalo blocks (in markdown content)\n      // Just need to update block offsets\n      this.updateBlockOffsets(edit, newSource);\n      return {\n        blockBoundariesChanged: false,\n        modifiedBlockIndices: [],\n        fullReparse: false,\n      };\n    }\n\n    if (affectedBlockIndices.length === 1) {\n      // Edit is within a single block - can use incremental parsing\n      const blockIndex = affectedBlockIndices[0];\n      this.updateSingleBlockIncremental(blockIndex, edit, newSource);\n      return {\n        blockBoundariesChanged: false,\n        modifiedBlockIndices: affectedBlockIndices,\n        fullReparse: false,\n      };\n    }\n\n    // Edit spans multiple blocks - do a full reparse\n    this._blocks = this.parseBlocks(newSource);\n    return {\n      blockBoundariesChanged: false,\n      modifiedBlockIndices: this._blocks.map((_, i) => i),\n      fullReparse: true,\n    };\n  }\n\n  /**\n   * Update block offsets after an edit outside all blocks.\n   */\n  private updateBlockOffsets(edit: EditRange, newSource: string): void {\n    const delta = edit.newEndIndex - edit.oldEndIndex;\n\n    this._blocks = this._blocks.map((block) => {\n      if (block.startOffset > edit.oldEndIndex) {\n        // Block is after the edit - shift offsets\n        return {\n          ...block,\n          startOffset: block.startOffset + delta,\n          endOffset: block.endOffset + delta,\n          sourceMap: createSourceMap(newSource, block.startOffset + delta, block.source),\n        };\n      }\n      return block;\n    });\n  }\n\n  /**\n   * Update a single block using incremental parsing.\n   */\n  private updateSingleBlockIncremental(\n    blockIndex: number,\n    edit: EditRange,\n    newSource: string,\n  ): void {\n    const oldBlock = this._blocks[blockIndex];\n\n    // Convert edit to block-relative coordinates\n    const blockRelativeStartIndex = edit.startIndex - oldBlock.startOffset;\n    const blockRelativeOldEndIndex = edit.oldEndIndex - oldBlock.startOffset;\n\n    // Compute the new block source\n    const delta = edit.newEndIndex - edit.oldEndIndex;\n    const newBlockEndOffset = oldBlock.endOffset + delta;\n\n    // Extract the new block content\n    // Need to find the new block boundaries in the edited source\n    const newBlockSource = newSource.slice(oldBlock.startOffset, newBlockEndOffset);\n\n    // Compute block-relative edit\n    const blockRelativeNewEndIndex = blockRelativeStartIndex + (edit.newEndIndex - edit.startIndex);\n    const blockRelativeEdit = computeEdit(\n      new LineIndex(oldBlock.source),\n      edit.startPosition.row - oldBlock.sourceMap.lineOffset,\n      edit.startPosition.row === oldBlock.sourceMap.lineOffset\n        ? edit.startPosition.column - oldBlock.sourceMap.columnOffset\n        : edit.startPosition.column,\n      edit.oldEndPosition.row - oldBlock.sourceMap.lineOffset,\n      edit.oldEndPosition.row === oldBlock.sourceMap.lineOffset\n        ? edit.oldEndPosition.column - oldBlock.sourceMap.columnOffset\n        : edit.oldEndPosition.column,\n      newSource.slice(edit.startIndex, edit.newEndIndex),\n    );\n\n    // Tell tree-sitter about the edit\n    oldBlock.tree.edit({\n      startIndex: blockRelativeStartIndex,\n      oldEndIndex: blockRelativeOldEndIndex,\n      newEndIndex: blockRelativeNewEndIndex,\n      startPosition: blockRelativeEdit.startPosition,\n      oldEndPosition: blockRelativeEdit.oldEndPosition,\n      newEndPosition: blockRelativeEdit.newEndPosition,\n    });\n\n    // Reparse with the old tree\n    const newTree = this.parser.parseIncremental(newBlockSource, oldBlock.tree);\n\n    // Update blocks array\n    this._blocks = this._blocks.map((block, i) => {\n      if (i === blockIndex) {\n        return {\n          source: newBlockSource,\n          sourceMap: createSourceMap(newSource, oldBlock.startOffset, newBlockSource),\n          tree: newTree,\n          startOffset: oldBlock.startOffset,\n          endOffset: newBlockEndOffset,\n        };\n      } else if (i > blockIndex) {\n        // Shift subsequent blocks\n        return {\n          ...block,\n          startOffset: block.startOffset + delta,\n          endOffset: block.endOffset + delta,\n          sourceMap: createSourceMap(newSource, block.startOffset + delta, block.source),\n        };\n      }\n      return block;\n    });\n  }\n}\n"],"mappings":";;;;;;;;AAwDA,MAAM,oBAAoB;;;;;;;;AAS1B,IAAa,WAAb,MAAa,SAA8C;CACzD,AAAS;CACT,AAAS;CAET,AAAQ;CACR,AAAQ;CACR,AAAQ;CACR,AAAQ;;;;;;;;;CAUR,YAAY,QAAwB,UAAkB,QAAgB,UAAqB;AACzF,OAAK,SAAS;AACd,OAAK,WAAW;AAChB,OAAK,UAAU;AACf,OAAK,WAAW,YAAY,SAAS,eAAe,UAAU,OAAO;AACrE,OAAK,aAAa,IAAI,UAAU,KAAK,QAAQ;AAC7C,OAAK,UAAU,KAAK,YAAY,KAAK,QAAQ;;;;;CAM/C,IAAI,SAAiB;AACnB,SAAO,KAAK;;;;;CAMd,IAAI,YAAuB;AACzB,SAAO,KAAK;;;;;CAMd,IAAI,SAAsC;AACxC,SAAO,KAAK;;;;;;;;;;;;CAad,UACE,WACA,aACA,SACA,WACA,SACY;EAEZ,MAAM,OAAO,YAAY,KAAK,YAAY,WAAW,aAAa,SAAS,WAAW,QAAQ;EAG9F,MAAM,YACJ,KAAK,QAAQ,MAAM,GAAG,KAAK,WAAW,GAAG,UAAU,KAAK,QAAQ,MAAM,KAAK,YAAY;EAGzF,MAAM,yBACJ,KAAK,aAAa,cAAc,KAAK,2BAA2B,MAAM,QAAQ;EAGhF,MAAM,YAAY,KAAK;AACvB,OAAK,UAAU;AACf,OAAK,aAAa,IAAI,UAAU,UAAU;AAG1C,MAAI,wBAAwB;AAC1B,QAAK,UAAU,KAAK,YAAY,UAAU;AAC1C,UAAO;IACL,wBAAwB;IACxB,sBAAsB,KAAK,QAAQ,KAAK,GAAG,MAAM,EAAE;IACnD,aAAa;IACd;;AAIH,MAAI,KAAK,aAAa,QAEpB,QAAO,KAAK,qBAAqB,MAAM,WAAW,WAAW,QAAQ;MAGrE,QAAO,KAAK,kBAAkB,MAAM,WAAW,WAAW,QAAQ;;;;;CAOtE,eAAe,MAAiB,SAA6B;EAC3D,MAAM,WAAW,KAAK,WAAW,iBAAiB,KAAK,WAAW;EAClE,MAAM,SAAS,KAAK,WAAW,iBAAiB,KAAK,YAAY;AACjE,SAAO,KAAK,UAAU,SAAS,MAAM,SAAS,QAAQ,OAAO,MAAM,OAAO,QAAQ,QAAQ;;;;;CAM5F,eAAe,WAAyB;AACtC,OAAK,UAAU;AACf,OAAK,aAAa,IAAI,UAAU,UAAU;AAC1C,OAAK,UAAU,KAAK,YAAY,UAAU;;;;;CAM5C,OAAe,eAAe,UAAkB,QAA0B;AACxE,MAAI,SAAS,SAAS,SAAS,CAC7B,QAAO;AAET,MAAI,SAAS,SAAS,MAAM,CAC1B,QAAO;AAGT,MAAI,OAAO,SAAS,WAAW,CAC7B,QAAO;AAET,SAAO;;;;;CAMT,AAAQ,YAAY,QAAoC;AACtD,MAAI,KAAK,aAAa,SAAS;GAE7B,MAAM,OAAO,KAAK,OAAO,MAAM,OAAO;AACtC,UAAO,CACL;IACE;IACA,WAAW,mBAAmB;IAC9B;IACA,aAAa;IACb,WAAW,OAAO;IACnB,CACF;;EAIH,MAAMA,SAA6B,EAAE;EACrC,IAAIC;AAEJ,UAAQ,QAAQ,kBAAkB,KAAK,OAAO,MAAM,MAAM;GACxD,MAAM,UAAU,MAAM;GACtB,MAAM,eAAe,MAAM,QAAQ,MAAM,GAAG,QAAQ,QAAQ;GAC5D,MAAM,YAAY,gBAAgB,QAAQ,cAAc,QAAQ;GAChE,MAAM,OAAO,KAAK,OAAO,MAAM,QAAQ;AAEvC,UAAO,KAAK;IACV,QAAQ;IACR;IACA;IACA,aAAa;IACb,WAAW,eAAe,QAAQ;IACnC,CAAC;;AAIJ,oBAAkB,YAAY;AAE9B,SAAO;;;;;CAMT,AAAQ,2BAA2B,MAAiB,SAA0B;EAG5E,MAAM,gBADU,KAAK,QAAQ,MAAM,KAAK,YAAY,KAAK,YAAY,CACvC,SAAS,MAAM;EAC7C,MAAM,gBAAgB,QAAQ,SAAS,MAAM;AAE7C,MAAI,iBAAiB,cACnB,QAAO;AAIT,OAAK,MAAM,SAAS,KAAK,SAAS;GAEhC,MAAM,mBAAmB,MAAM,cAAc;AAC7C,OAAI,oBAAoB,KAAK,cAAc,mBAAmB,KAAK,YACjE,QAAO;GAGT,MAAM,iBAAiB,MAAM;AAC7B,OAAI,kBAAkB,KAAK,cAAc,iBAAiB,KAAK,YAC7D,QAAO;;AAIX,SAAO;;;;;CAMT,AAAQ,qBACN,MACA,YACA,WACA,UACY;EACZ,MAAM,QAAQ,KAAK,QAAQ;AAG3B,QAAM,KAAK,KAAK;GACd,YAAY,KAAK;GACjB,aAAa,KAAK;GAClB,aAAa,KAAK;GAClB,eAAe,KAAK;GACpB,gBAAgB,KAAK;GACrB,gBAAgB,KAAK;GACtB,CAAC;EAGF,MAAM,UAAU,KAAK,OAAO,iBAAiB,WAAW,MAAM,KAAK;AAGnE,OAAK,UAAU,CACb;GACE,QAAQ;GACR,WAAW,mBAAmB;GAC9B,MAAM;GACN,aAAa;GACb,WAAW,UAAU;GACtB,CACF;AAED,SAAO;GACL,wBAAwB;GACxB,sBAAsB,CAAC,EAAE;GACzB,aAAa;GACd;;;;;CAMH,AAAQ,kBACN,MACA,YACA,WACA,UACY;EAEZ,MAAMC,uBAAiC,EAAE;AAEzC,OAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,QAAQ,KAAK;GAC5C,MAAM,QAAQ,KAAK,QAAQ;AAE3B,OAAI,KAAK,aAAa,MAAM,aAAa,KAAK,cAAc,MAAM,YAChE,sBAAqB,KAAK,EAAE;;AAIhC,MAAI,qBAAqB,WAAW,GAAG;AAGrC,QAAK,mBAAmB,MAAM,UAAU;AACxC,UAAO;IACL,wBAAwB;IACxB,sBAAsB,EAAE;IACxB,aAAa;IACd;;AAGH,MAAI,qBAAqB,WAAW,GAAG;GAErC,MAAM,aAAa,qBAAqB;AACxC,QAAK,6BAA6B,YAAY,MAAM,UAAU;AAC9D,UAAO;IACL,wBAAwB;IACxB,sBAAsB;IACtB,aAAa;IACd;;AAIH,OAAK,UAAU,KAAK,YAAY,UAAU;AAC1C,SAAO;GACL,wBAAwB;GACxB,sBAAsB,KAAK,QAAQ,KAAK,GAAG,MAAM,EAAE;GACnD,aAAa;GACd;;;;;CAMH,AAAQ,mBAAmB,MAAiB,WAAyB;EACnE,MAAM,QAAQ,KAAK,cAAc,KAAK;AAEtC,OAAK,UAAU,KAAK,QAAQ,KAAK,UAAU;AACzC,OAAI,MAAM,cAAc,KAAK,YAE3B,QAAO;IACL,GAAG;IACH,aAAa,MAAM,cAAc;IACjC,WAAW,MAAM,YAAY;IAC7B,WAAW,gBAAgB,WAAW,MAAM,cAAc,OAAO,MAAM,OAAO;IAC/E;AAEH,UAAO;IACP;;;;;CAMJ,AAAQ,6BACN,YACA,MACA,WACM;EACN,MAAM,WAAW,KAAK,QAAQ;EAG9B,MAAM,0BAA0B,KAAK,aAAa,SAAS;EAC3D,MAAM,2BAA2B,KAAK,cAAc,SAAS;EAG7D,MAAM,QAAQ,KAAK,cAAc,KAAK;EACtC,MAAM,oBAAoB,SAAS,YAAY;EAI/C,MAAM,iBAAiB,UAAU,MAAM,SAAS,aAAa,kBAAkB;EAG/E,MAAM,2BAA2B,2BAA2B,KAAK,cAAc,KAAK;EACpF,MAAM,oBAAoB,YACxB,IAAI,UAAU,SAAS,OAAO,EAC9B,KAAK,cAAc,MAAM,SAAS,UAAU,YAC5C,KAAK,cAAc,QAAQ,SAAS,UAAU,aAC1C,KAAK,cAAc,SAAS,SAAS,UAAU,eAC/C,KAAK,cAAc,QACvB,KAAK,eAAe,MAAM,SAAS,UAAU,YAC7C,KAAK,eAAe,QAAQ,SAAS,UAAU,aAC3C,KAAK,eAAe,SAAS,SAAS,UAAU,eAChD,KAAK,eAAe,QACxB,UAAU,MAAM,KAAK,YAAY,KAAK,YAAY,CACnD;AAGD,WAAS,KAAK,KAAK;GACjB,YAAY;GACZ,aAAa;GACb,aAAa;GACb,eAAe,kBAAkB;GACjC,gBAAgB,kBAAkB;GAClC,gBAAgB,kBAAkB;GACnC,CAAC;EAGF,MAAM,UAAU,KAAK,OAAO,iBAAiB,gBAAgB,SAAS,KAAK;AAG3E,OAAK,UAAU,KAAK,QAAQ,KAAK,OAAO,MAAM;AAC5C,OAAI,MAAM,WACR,QAAO;IACL,QAAQ;IACR,WAAW,gBAAgB,WAAW,SAAS,aAAa,eAAe;IAC3E,MAAM;IACN,aAAa,SAAS;IACtB,WAAW;IACZ;YACQ,IAAI,WAEb,QAAO;IACL,GAAG;IACH,aAAa,MAAM,cAAc;IACjC,WAAW,MAAM,YAAY;IAC7B,WAAW,gBAAgB,WAAW,MAAM,cAAc,OAAO,MAAM,OAAO;IAC/E;AAEH,UAAO;IACP"}