@rejot-dev/thalo 0.0.0

package/dist/checker/visitor.d.ts

@@ -0,0 +1,69 @@
+import { ActualizeEntry, InstanceEntry, SchemaEntry, SynthesisEntry } from "../ast/ast-types.js";
+import { SourceMap } from "../source-map.js";
+import { SemanticModel } from "../semantic/analyzer.js";
+import { Workspace } from "../model/workspace.js";
+import { WorkspaceIndex } from "./workspace-index.js";
+import { PartialDiagnostic } from "./check.js";
+
+//#region src/checker/visitor.d.ts
+
+/**
+ * Context available to visitors during the check phase.
+ */
+interface VisitorContext {
+  /** The workspace being checked */
+  workspace: Workspace;
+  /** Pre-computed indices for efficient queries */
+  index: WorkspaceIndex;
+  /** Report a diagnostic */
+  report(diagnostic: PartialDiagnostic): void;
+}
+/**
+ * Context available when visiting a specific entry.
+ */
+interface EntryContext extends VisitorContext {
+  /** The semantic model containing the entry */
+  model: SemanticModel;
+  /** The file path */
+  file: string;
+  /** Source map for position translation */
+  sourceMap: SourceMap;
+}
+/**
+ * Visitor interface for rule implementations.
+ *
+ * Rules implement this interface to receive callbacks during the check phase.
+ * Instead of each rule iterating over all entries, a single pass dispatches
+ * to all registered visitors.
+ */
+interface RuleVisitor {
+  /**
+   * Called once before visiting any entries.
+   * Use this for initialization or pre-processing.
+   */
+  beforeCheck?(ctx: VisitorContext): void;
+  /**
+   * Called for each instance entry (create/update).
+   */
+  visitInstanceEntry?(entry: InstanceEntry, ctx: EntryContext): void;
+  /**
+   * Called for each schema entry (define-entity/alter-entity).
+   */
+  visitSchemaEntry?(entry: SchemaEntry, ctx: EntryContext): void;
+  /**
+   * Called for each synthesis entry (define-synthesis).
+   */
+  visitSynthesisEntry?(entry: SynthesisEntry, ctx: EntryContext): void;
+  /**
+   * Called for each actualize entry (actualize-synthesis).
+   */
+  visitActualizeEntry?(entry: ActualizeEntry, ctx: EntryContext): void;
+  /**
+   * Called once after visiting all entries.
+   * Use this for cross-entry checks that need all data collected first.
+   */
+  afterCheck?(ctx: VisitorContext): void;
+}
+//#endregion
+export { RuleVisitor };
+//# sourceMappingURL=visitor.d.ts.map

package/dist/checker/visitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visitor.d.ts","names":[],"sources":["../../src/checker/visitor.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;AAgBA;AAEa,UAFI,cAAA,CAEJ;EAEJ;EAEY,SAAA,EAJR,SAIQ;EAAiB;EAMrB,KAAA,EARR,cAQqB;EAErB;EAII,MAAA,CAAA,UAAA,EAZQ,iBAYR,CAAA,EAAA,IAAA;;;AAUb;;AAU6B,UA1BZ,YAAA,SAAqB,cA0BT,CAAA;EAAoB;EAKtB,KAAA,EA7BlB,aA6BkB;EAAkB;EAKf,IAAA,EAAA,MAAA;EAAqB;EAKrB,SAAA,EAnCjB,SAmCiB;;;;;;;;;UAzBb,WAAA;;;;;oBAKG;;;;6BAKS,oBAAoB;;;;2BAKtB,kBAAkB;;;;8BAKf,qBAAqB;;;;8BAKrB,qBAAqB;;;;;mBAMhC"}

package/dist/checker/visitor.js

@@ -0,0 +1,67 @@
+//#region src/checker/visitor.ts
+/**
+* Dispatch an entry to the appropriate visitor method.
+*/
+function dispatchToVisitor(visitor, entry, ctx) {
+	switch (entry.type) {
+		case "instance_entry":
+			visitor.visitInstanceEntry?.(entry, ctx);
+			break;
+		case "schema_entry":
+			visitor.visitSchemaEntry?.(entry, ctx);
+			break;
+		case "synthesis_entry":
+			visitor.visitSynthesisEntry?.(entry, ctx);
+			break;
+		case "actualize_entry":
+			visitor.visitActualizeEntry?.(entry, ctx);
+			break;
+	}
+}
+/**
+* Run a single pass over all entries, dispatching to all visitors.
+*
+* This is more efficient than each rule iterating independently.
+*/
+function runVisitors(visitors, workspace, index, report) {
+	const visitorCtx = {
+		workspace,
+		index,
+		report
+	};
+	for (const visitor of visitors) visitor.beforeCheck?.(visitorCtx);
+	for (const model of workspace.allModels()) {
+		const entryCtx = {
+			...visitorCtx,
+			model,
+			file: model.file,
+			sourceMap: model.sourceMap
+		};
+		for (const entry of model.ast.entries) for (const visitor of visitors) dispatchToVisitor(visitor, entry, entryCtx);
+	}
+	for (const visitor of visitors) visitor.afterCheck?.(visitorCtx);
+}
+/**
+* Run visitors on a single model only.
+* Useful for document-scoped checks.
+*/
+function runVisitorsOnModel(visitors, model, workspace, index, report) {
+	const visitorCtx = {
+		workspace,
+		index,
+		report
+	};
+	const entryCtx = {
+		...visitorCtx,
+		model,
+		file: model.file,
+		sourceMap: model.sourceMap
+	};
+	for (const visitor of visitors) visitor.beforeCheck?.(visitorCtx);
+	for (const entry of model.ast.entries) for (const visitor of visitors) dispatchToVisitor(visitor, entry, entryCtx);
+	for (const visitor of visitors) visitor.afterCheck?.(visitorCtx);
+}
+
+//#endregion
+export { runVisitors, runVisitorsOnModel };
+//# sourceMappingURL=visitor.js.map

package/dist/checker/visitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visitor.js","names":["visitorCtx: VisitorContext","entryCtx: EntryContext"],"sources":["../../src/checker/visitor.ts"],"sourcesContent":["import type {\n  Entry,\n  InstanceEntry,\n  SchemaEntry,\n  SynthesisEntry,\n  ActualizeEntry,\n} from \"../ast/ast-types.js\";\nimport type { SemanticModel } from \"../semantic/analyzer.js\";\nimport type { SourceMap } from \"../source-map.js\";\nimport type { Workspace } from \"../model/workspace.js\";\nimport type { WorkspaceIndex } from \"./workspace-index.js\";\nimport type { PartialDiagnostic } from \"./check.js\";\n\n/**\n * Context available to visitors during the check phase.\n */\nexport interface VisitorContext {\n  /** The workspace being checked */\n  workspace: Workspace;\n  /** Pre-computed indices for efficient queries */\n  index: WorkspaceIndex;\n  /** Report a diagnostic */\n  report(diagnostic: PartialDiagnostic): void;\n}\n\n/**\n * Context available when visiting a specific entry.\n */\nexport interface EntryContext extends VisitorContext {\n  /** The semantic model containing the entry */\n  model: SemanticModel;\n  /** The file path */\n  file: string;\n  /** Source map for position translation */\n  sourceMap: SourceMap;\n}\n\n/**\n * Visitor interface for rule implementations.\n *\n * Rules implement this interface to receive callbacks during the check phase.\n * Instead of each rule iterating over all entries, a single pass dispatches\n * to all registered visitors.\n */\nexport interface RuleVisitor {\n  /**\n   * Called once before visiting any entries.\n   * Use this for initialization or pre-processing.\n   */\n  beforeCheck?(ctx: VisitorContext): void;\n\n  /**\n   * Called for each instance entry (create/update).\n   */\n  visitInstanceEntry?(entry: InstanceEntry, ctx: EntryContext): void;\n\n  /**\n   * Called for each schema entry (define-entity/alter-entity).\n   */\n  visitSchemaEntry?(entry: SchemaEntry, ctx: EntryContext): void;\n\n  /**\n   * Called for each synthesis entry (define-synthesis).\n   */\n  visitSynthesisEntry?(entry: SynthesisEntry, ctx: EntryContext): void;\n\n  /**\n   * Called for each actualize entry (actualize-synthesis).\n   */\n  visitActualizeEntry?(entry: ActualizeEntry, ctx: EntryContext): void;\n\n  /**\n   * Called once after visiting all entries.\n   * Use this for cross-entry checks that need all data collected first.\n   */\n  afterCheck?(ctx: VisitorContext): void;\n}\n\n/**\n * Dispatch an entry to the appropriate visitor method.\n */\nexport function dispatchToVisitor(visitor: RuleVisitor, entry: Entry, ctx: EntryContext): void {\n  switch (entry.type) {\n    case \"instance_entry\":\n      visitor.visitInstanceEntry?.(entry, ctx);\n      break;\n    case \"schema_entry\":\n      visitor.visitSchemaEntry?.(entry, ctx);\n      break;\n    case \"synthesis_entry\":\n      visitor.visitSynthesisEntry?.(entry, ctx);\n      break;\n    case \"actualize_entry\":\n      visitor.visitActualizeEntry?.(entry, ctx);\n      break;\n  }\n}\n\n/**\n * Run a single pass over all entries, dispatching to all visitors.\n *\n * This is more efficient than each rule iterating independently.\n */\nexport function runVisitors(\n  visitors: RuleVisitor[],\n  workspace: Workspace,\n  index: WorkspaceIndex,\n  report: (diagnostic: PartialDiagnostic) => void,\n): void {\n  const visitorCtx: VisitorContext = {\n    workspace,\n    index,\n    report,\n  };\n\n  // Call beforeCheck on all visitors\n  for (const visitor of visitors) {\n    visitor.beforeCheck?.(visitorCtx);\n  }\n\n  // Single pass over all models and entries\n  for (const model of workspace.allModels()) {\n    const entryCtx: EntryContext = {\n      ...visitorCtx,\n      model,\n      file: model.file,\n      sourceMap: model.sourceMap,\n    };\n\n    for (const entry of model.ast.entries) {\n      // Dispatch to all visitors\n      for (const visitor of visitors) {\n        dispatchToVisitor(visitor, entry, entryCtx);\n      }\n    }\n  }\n\n  // Call afterCheck on all visitors\n  for (const visitor of visitors) {\n    visitor.afterCheck?.(visitorCtx);\n  }\n}\n\n/**\n * Run visitors on a single model only.\n * Useful for document-scoped checks.\n */\nexport function runVisitorsOnModel(\n  visitors: RuleVisitor[],\n  model: SemanticModel,\n  workspace: Workspace,\n  index: WorkspaceIndex,\n  report: (diagnostic: PartialDiagnostic) => void,\n): void {\n  const visitorCtx: VisitorContext = {\n    workspace,\n    index,\n    report,\n  };\n\n  const entryCtx: EntryContext = {\n    ...visitorCtx,\n    model,\n    file: model.file,\n    sourceMap: model.sourceMap,\n  };\n\n  // Call beforeCheck on all visitors\n  for (const visitor of visitors) {\n    visitor.beforeCheck?.(visitorCtx);\n  }\n\n  // Iterate over entries in this model only\n  for (const entry of model.ast.entries) {\n    for (const visitor of visitors) {\n      dispatchToVisitor(visitor, entry, entryCtx);\n    }\n  }\n\n  // Call afterCheck on all visitors\n  for (const visitor of visitors) {\n    visitor.afterCheck?.(visitorCtx);\n  }\n}\n\n/**\n * Run visitors on specific entries only.\n * Useful for incremental checks on changed entries.\n */\nexport function runVisitorsOnEntries(\n  visitors: RuleVisitor[],\n  entries: Entry[],\n  model: SemanticModel,\n  workspace: Workspace,\n  index: WorkspaceIndex,\n  report: (diagnostic: PartialDiagnostic) => void,\n): void {\n  const visitorCtx: VisitorContext = {\n    workspace,\n    index,\n    report,\n  };\n\n  const entryCtx: EntryContext = {\n    ...visitorCtx,\n    model,\n    file: model.file,\n    sourceMap: model.sourceMap,\n  };\n\n  // Note: We don't call beforeCheck/afterCheck for incremental checks\n  // as they typically need full workspace data\n\n  for (const entry of entries) {\n    for (const visitor of visitors) {\n      dispatchToVisitor(visitor, entry, entryCtx);\n    }\n  }\n}\n"],"mappings":";;;;AAiFA,SAAgB,kBAAkB,SAAsB,OAAc,KAAyB;AAC7F,SAAQ,MAAM,MAAd;EACE,KAAK;AACH,WAAQ,qBAAqB,OAAO,IAAI;AACxC;EACF,KAAK;AACH,WAAQ,mBAAmB,OAAO,IAAI;AACtC;EACF,KAAK;AACH,WAAQ,sBAAsB,OAAO,IAAI;AACzC;EACF,KAAK;AACH,WAAQ,sBAAsB,OAAO,IAAI;AACzC;;;;;;;;AASN,SAAgB,YACd,UACA,WACA,OACA,QACM;CACN,MAAMA,aAA6B;EACjC;EACA;EACA;EACD;AAGD,MAAK,MAAM,WAAW,SACpB,SAAQ,cAAc,WAAW;AAInC,MAAK,MAAM,SAAS,UAAU,WAAW,EAAE;EACzC,MAAMC,WAAyB;GAC7B,GAAG;GACH;GACA,MAAM,MAAM;GACZ,WAAW,MAAM;GAClB;AAED,OAAK,MAAM,SAAS,MAAM,IAAI,QAE5B,MAAK,MAAM,WAAW,SACpB,mBAAkB,SAAS,OAAO,SAAS;;AAMjD,MAAK,MAAM,WAAW,SACpB,SAAQ,aAAa,WAAW;;;;;;AAQpC,SAAgB,mBACd,UACA,OACA,WACA,OACA,QACM;CACN,MAAMD,aAA6B;EACjC;EACA;EACA;EACD;CAED,MAAMC,WAAyB;EAC7B,GAAG;EACH;EACA,MAAM,MAAM;EACZ,WAAW,MAAM;EAClB;AAGD,MAAK,MAAM,WAAW,SACpB,SAAQ,cAAc,WAAW;AAInC,MAAK,MAAM,SAAS,MAAM,IAAI,QAC5B,MAAK,MAAM,WAAW,SACpB,mBAAkB,SAAS,OAAO,SAAS;AAK/C,MAAK,MAAM,WAAW,SACpB,SAAQ,aAAa,WAAW"}

package/dist/checker/workspace-index.d.ts

@@ -0,0 +1,50 @@
+import { ActualizeEntry, Entry, InstanceEntry, SchemaEntry, SynthesisEntry } from "../ast/ast-types.js";
+import { SourceMap } from "../source-map.js";
+import { SemanticModel } from "../semantic/analyzer.js";
+
+//#region src/checker/workspace-index.d.ts
+
+/**
+ * An entry with its context (model, file, sourceMap) for reporting diagnostics.
+ */
+interface IndexedEntry<T extends Entry> {
+  /** The AST entry */
+  entry: T;
+  /** The semantic model containing this entry */
+  model: SemanticModel;
+  /** The file path */
+  file: string;
+  /** Source map for position translation */
+  sourceMap: SourceMap;
+}
+/**
+ * Pre-computed indices for efficient rule execution.
+ *
+ * Instead of each rule iterating over all models and entries,
+ * rules can query this index for pre-grouped data.
+ */
+interface WorkspaceIndex {
+  /** All instance entries (create/update) */
+  readonly instanceEntries: IndexedEntry<InstanceEntry>[];
+  /** All schema entries (define-entity/alter-entity) */
+  readonly schemaEntries: IndexedEntry<SchemaEntry>[];
+  /** All synthesis entries (define-synthesis) */
+  readonly synthesisEntries: IndexedEntry<SynthesisEntry>[];
+  /** All actualize entries (actualize-synthesis) */
+  readonly actualizeEntries: IndexedEntry<ActualizeEntry>[];
+  /** define-entity entries grouped by entity name */
+  readonly defineEntitiesByName: ReadonlyMap<string, IndexedEntry<SchemaEntry>[]>;
+  /** alter-entity entries grouped by entity name */
+  readonly alterEntitiesByName: ReadonlyMap<string, IndexedEntry<SchemaEntry>[]>;
+  /** Instance entries grouped by entity type */
+  readonly instancesByEntity: ReadonlyMap<string, IndexedEntry<InstanceEntry>[]>;
+  /** Instance entries by their link ID (for entries that define a link) */
+  readonly instancesByLinkId: ReadonlyMap<string, IndexedEntry<InstanceEntry>>;
+  /** Entries that reference a specific link ID (in metadata or as actualize target) */
+  readonly entriesReferencingLink: ReadonlyMap<string, IndexedEntry<Entry>[]>;
+  /** Entries that use a specific entity type (instance entries) */
+  readonly entriesUsingEntity: ReadonlyMap<string, IndexedEntry<Entry>[]>;
+}
+//#endregion
+export { WorkspaceIndex };
+//# sourceMappingURL=workspace-index.d.ts.map

package/dist/checker/workspace-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-index.d.ts","names":[],"sources":["../../src/checker/workspace-index.ts"],"sourcesContent":[],"mappings":";;;;;;;AAcA;;AAES,UAFQ,YAER,CAAA,UAF+B,KAE/B,CAAA,CAAA;EAEA;EAII,KAAA,EANJ,CAMI;EAAS;EASL,KAAA,EAbR,aAasB;EAGU;EAAb,IAAA,EAAA,MAAA;EAEW;EAAb,SAAA,EAdb,SAca;;;;;;;;AAUuC,UAfhD,cAAA,CAegD;EAAb;EAApB,SAAA,eAAA,EAZJ,YAYI,CAZS,aAYT,CAAA,EAAA;EAI+B;EAAb,SAAA,aAAA,EAdxB,YAcwB,CAdX,WAcW,CAAA,EAAA;EAApB;EAEiC,SAAA,gBAAA,EAdlC,YAckC,CAdrB,cAcqB,CAAA,EAAA;EAAb;EAApB,SAAA,gBAAA,EAZD,YAYC,CAZY,cAYZ,CAAA,EAAA;EAIsC;EAAb,SAAA,oBAAA,EAZtB,WAYsB,CAAA,MAAA,EAZF,YAYE,CAZW,WAYX,CAAA,EAAA,CAAA;EAApB;EAE6B,SAAA,mBAAA,EAZhC,WAYgC,CAAA,MAAA,EAZZ,YAYY,CAZC,WAYD,CAAA,EAAA,CAAA;EAAb;EAApB,SAAA,iBAAA,EARD,WAQC,CAAA,MAAA,EARmB,YAQnB,CARgC,aAQhC,CAAA,EAAA,CAAA;EAAW;8BANZ,oBAAoB,aAAa;;mCAI5B,oBAAoB,aAAa;;+BAErC,oBAAoB,aAAa"}

package/dist/checker/workspace-index.js

@@ -0,0 +1,108 @@
+//#region src/checker/workspace-index.ts
+/**
+* Create an empty workspace index builder.
+*/
+function createEmptyBuilder() {
+	return {
+		instanceEntries: [],
+		schemaEntries: [],
+		synthesisEntries: [],
+		actualizeEntries: [],
+		defineEntitiesByName: /* @__PURE__ */ new Map(),
+		alterEntitiesByName: /* @__PURE__ */ new Map(),
+		instancesByEntity: /* @__PURE__ */ new Map(),
+		instancesByLinkId: /* @__PURE__ */ new Map(),
+		entriesReferencingLink: /* @__PURE__ */ new Map(),
+		entriesUsingEntity: /* @__PURE__ */ new Map()
+	};
+}
+/**
+* Add an item to a map of arrays.
+*/
+function addToMapArray(map, key, value) {
+	const arr = map.get(key);
+	if (arr) arr.push(value);
+	else map.set(key, [value]);
+}
+/**
+* Extract link IDs referenced in an entry's metadata.
+*/
+function getReferencedLinkIds(entry) {
+	const linkIds = [];
+	if (entry.type === "instance_entry" || entry.type === "synthesis_entry") for (const m of entry.metadata) {
+		const content = m.value.content;
+		if (content.type === "link_value") linkIds.push(content.link.id);
+		else if (content.type === "value_array") {
+			for (const element of content.elements) if (element.type === "link") linkIds.push(element.id);
+		}
+	}
+	else if (entry.type === "actualize_entry") {
+		linkIds.push(entry.header.target.id);
+		for (const m of entry.metadata) {
+			const content = m.value.content;
+			if (content.type === "link_value") linkIds.push(content.link.id);
+			else if (content.type === "value_array") {
+				for (const element of content.elements) if (element.type === "link") linkIds.push(element.id);
+			}
+		}
+	}
+	return linkIds;
+}
+/**
+* Build a WorkspaceIndex from a Workspace in a single pass.
+*
+* This is more efficient than having each rule iterate over all models
+* and entries independently. Rules can query the pre-built index instead.
+*/
+function buildWorkspaceIndex(workspace) {
+	const builder = createEmptyBuilder();
+	for (const model of workspace.allModels()) {
+		const file = model.file;
+		const sourceMap = model.sourceMap;
+		for (const entry of model.ast.entries) {
+			const indexed = {
+				entry,
+				model,
+				file,
+				sourceMap
+			};
+			switch (entry.type) {
+				case "instance_entry": {
+					const instanceIndexed = indexed;
+					builder.instanceEntries.push(instanceIndexed);
+					const entityName = entry.header.entity;
+					addToMapArray(builder.instancesByEntity, entityName, instanceIndexed);
+					addToMapArray(builder.entriesUsingEntity, entityName, indexed);
+					if (entry.header.link) builder.instancesByLinkId.set(entry.header.link.id, instanceIndexed);
+					for (const linkId of getReferencedLinkIds(entry)) addToMapArray(builder.entriesReferencingLink, linkId, indexed);
+					break;
+				}
+				case "schema_entry": {
+					const schemaIndexed = indexed;
+					builder.schemaEntries.push(schemaIndexed);
+					const entityName = entry.header.entityName.value;
+					if (entry.header.directive === "define-entity") addToMapArray(builder.defineEntitiesByName, entityName, schemaIndexed);
+					else addToMapArray(builder.alterEntitiesByName, entityName, schemaIndexed);
+					break;
+				}
+				case "synthesis_entry": {
+					const synthesisIndexed = indexed;
+					builder.synthesisEntries.push(synthesisIndexed);
+					for (const linkId of getReferencedLinkIds(entry)) addToMapArray(builder.entriesReferencingLink, linkId, indexed);
+					break;
+				}
+				case "actualize_entry": {
+					const actualizeIndexed = indexed;
+					builder.actualizeEntries.push(actualizeIndexed);
+					for (const linkId of getReferencedLinkIds(entry)) addToMapArray(builder.entriesReferencingLink, linkId, indexed);
+					break;
+				}
+			}
+		}
+	}
+	return builder;
+}
+
+//#endregion
+export { buildWorkspaceIndex };
+//# sourceMappingURL=workspace-index.js.map

package/dist/checker/workspace-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-index.js","names":["linkIds: string[]"],"sources":["../../src/checker/workspace-index.ts"],"sourcesContent":["import type {\n  Entry,\n  InstanceEntry,\n  SchemaEntry,\n  SynthesisEntry,\n  ActualizeEntry,\n} from \"../ast/ast-types.js\";\nimport type { SemanticModel } from \"../semantic/analyzer.js\";\nimport type { SourceMap } from \"../source-map.js\";\nimport type { Workspace } from \"../model/workspace.js\";\n\n/**\n * An entry with its context (model, file, sourceMap) for reporting diagnostics.\n */\nexport interface IndexedEntry<T extends Entry> {\n  /** The AST entry */\n  entry: T;\n  /** The semantic model containing this entry */\n  model: SemanticModel;\n  /** The file path */\n  file: string;\n  /** Source map for position translation */\n  sourceMap: SourceMap;\n}\n\n/**\n * Pre-computed indices for efficient rule execution.\n *\n * Instead of each rule iterating over all models and entries,\n * rules can query this index for pre-grouped data.\n */\nexport interface WorkspaceIndex {\n  // Entry indices by type\n  /** All instance entries (create/update) */\n  readonly instanceEntries: IndexedEntry<InstanceEntry>[];\n  /** All schema entries (define-entity/alter-entity) */\n  readonly schemaEntries: IndexedEntry<SchemaEntry>[];\n  /** All synthesis entries (define-synthesis) */\n  readonly synthesisEntries: IndexedEntry<SynthesisEntry>[];\n  /** All actualize entries (actualize-synthesis) */\n  readonly actualizeEntries: IndexedEntry<ActualizeEntry>[];\n\n  // Pre-grouped indices for schema entries\n  /** define-entity entries grouped by entity name */\n  readonly defineEntitiesByName: ReadonlyMap<string, IndexedEntry<SchemaEntry>[]>;\n  /** alter-entity entries grouped by entity name */\n  readonly alterEntitiesByName: ReadonlyMap<string, IndexedEntry<SchemaEntry>[]>;\n\n  // Pre-grouped indices for instance entries\n  /** Instance entries grouped by entity type */\n  readonly instancesByEntity: ReadonlyMap<string, IndexedEntry<InstanceEntry>[]>;\n  /** Instance entries by their link ID (for entries that define a link) */\n  readonly instancesByLinkId: ReadonlyMap<string, IndexedEntry<InstanceEntry>>;\n\n  // Cross-reference indices\n  /** Entries that reference a specific link ID (in metadata or as actualize target) */\n  readonly entriesReferencingLink: ReadonlyMap<string, IndexedEntry<Entry>[]>;\n  /** Entries that use a specific entity type (instance entries) */\n  readonly entriesUsingEntity: ReadonlyMap<string, IndexedEntry<Entry>[]>;\n}\n\n/**\n * Mutable builder for WorkspaceIndex.\n */\ninterface WorkspaceIndexBuilder {\n  instanceEntries: IndexedEntry<InstanceEntry>[];\n  schemaEntries: IndexedEntry<SchemaEntry>[];\n  synthesisEntries: IndexedEntry<SynthesisEntry>[];\n  actualizeEntries: IndexedEntry<ActualizeEntry>[];\n  defineEntitiesByName: Map<string, IndexedEntry<SchemaEntry>[]>;\n  alterEntitiesByName: Map<string, IndexedEntry<SchemaEntry>[]>;\n  instancesByEntity: Map<string, IndexedEntry<InstanceEntry>[]>;\n  instancesByLinkId: Map<string, IndexedEntry<InstanceEntry>>;\n  entriesReferencingLink: Map<string, IndexedEntry<Entry>[]>;\n  entriesUsingEntity: Map<string, IndexedEntry<Entry>[]>;\n}\n\n/**\n * Create an empty workspace index builder.\n */\nfunction createEmptyBuilder(): WorkspaceIndexBuilder {\n  return {\n    instanceEntries: [],\n    schemaEntries: [],\n    synthesisEntries: [],\n    actualizeEntries: [],\n    defineEntitiesByName: new Map(),\n    alterEntitiesByName: new Map(),\n    instancesByEntity: new Map(),\n    instancesByLinkId: new Map(),\n    entriesReferencingLink: new Map(),\n    entriesUsingEntity: new Map(),\n  };\n}\n\n/**\n * Add an item to a map of arrays.\n */\nfunction addToMapArray<K, V>(map: Map<K, V[]>, key: K, value: V): void {\n  const arr = map.get(key);\n  if (arr) {\n    arr.push(value);\n  } else {\n    map.set(key, [value]);\n  }\n}\n\n/**\n * Extract link IDs referenced in an entry's metadata.\n */\nfunction getReferencedLinkIds(entry: Entry): string[] {\n  const linkIds: string[] = [];\n\n  if (entry.type === \"instance_entry\" || entry.type === \"synthesis_entry\") {\n    for (const m of entry.metadata) {\n      const content = m.value.content;\n      if (content.type === \"link_value\") {\n        linkIds.push(content.link.id);\n      } else if (content.type === \"value_array\") {\n        for (const element of content.elements) {\n          if (element.type === \"link\") {\n            linkIds.push(element.id);\n          }\n        }\n      }\n    }\n  } else if (entry.type === \"actualize_entry\") {\n    // Actualize target is a reference\n    linkIds.push(entry.header.target.id);\n    // Plus any metadata links\n    for (const m of entry.metadata) {\n      const content = m.value.content;\n      if (content.type === \"link_value\") {\n        linkIds.push(content.link.id);\n      } else if (content.type === \"value_array\") {\n        for (const element of content.elements) {\n          if (element.type === \"link\") {\n            linkIds.push(element.id);\n          }\n        }\n      }\n    }\n  }\n\n  return linkIds;\n}\n\n/**\n * Build a WorkspaceIndex from a Workspace in a single pass.\n *\n * This is more efficient than having each rule iterate over all models\n * and entries independently. Rules can query the pre-built index instead.\n */\nexport function buildWorkspaceIndex(workspace: Workspace): WorkspaceIndex {\n  const builder = createEmptyBuilder();\n\n  // Single iteration over all models and entries\n  for (const model of workspace.allModels()) {\n    const file = model.file;\n    const sourceMap = model.sourceMap;\n\n    for (const entry of model.ast.entries) {\n      const indexed = { entry, model, file, sourceMap };\n\n      // Safe casts below: switch narrows entry.type, so the indexed cast is valid\n      switch (entry.type) {\n        case \"instance_entry\": {\n          const instanceIndexed = indexed as IndexedEntry<InstanceEntry>;\n          builder.instanceEntries.push(instanceIndexed);\n\n          // Group by entity\n          const entityName = entry.header.entity;\n          addToMapArray(builder.instancesByEntity, entityName, instanceIndexed);\n          addToMapArray(builder.entriesUsingEntity, entityName, indexed as IndexedEntry<Entry>);\n\n          // Index by link ID if present\n          if (entry.header.link) {\n            builder.instancesByLinkId.set(entry.header.link.id, instanceIndexed);\n          }\n\n          // Track link references\n          for (const linkId of getReferencedLinkIds(entry)) {\n            addToMapArray(builder.entriesReferencingLink, linkId, indexed as IndexedEntry<Entry>);\n          }\n          break;\n        }\n\n        case \"schema_entry\": {\n          const schemaIndexed = indexed as IndexedEntry<SchemaEntry>;\n          builder.schemaEntries.push(schemaIndexed);\n\n          const entityName = entry.header.entityName.value;\n          if (entry.header.directive === \"define-entity\") {\n            addToMapArray(builder.defineEntitiesByName, entityName, schemaIndexed);\n          } else {\n            addToMapArray(builder.alterEntitiesByName, entityName, schemaIndexed);\n          }\n          break;\n        }\n\n        case \"synthesis_entry\": {\n          const synthesisIndexed = indexed as IndexedEntry<SynthesisEntry>;\n          builder.synthesisEntries.push(synthesisIndexed);\n\n          // Track link references\n          for (const linkId of getReferencedLinkIds(entry)) {\n            addToMapArray(builder.entriesReferencingLink, linkId, indexed as IndexedEntry<Entry>);\n          }\n          break;\n        }\n\n        case \"actualize_entry\": {\n          const actualizeIndexed = indexed as IndexedEntry<ActualizeEntry>;\n          builder.actualizeEntries.push(actualizeIndexed);\n\n          // Track link references (including target)\n          for (const linkId of getReferencedLinkIds(entry)) {\n            addToMapArray(builder.entriesReferencingLink, linkId, indexed as IndexedEntry<Entry>);\n          }\n          break;\n        }\n      }\n    }\n  }\n\n  return builder as WorkspaceIndex;\n}\n\n/**\n * Get instance entries for a specific entity type from the index.\n */\nexport function getInstancesForEntity(\n  index: WorkspaceIndex,\n  entityName: string,\n): IndexedEntry<InstanceEntry>[] {\n  return index.instancesByEntity.get(entityName) ?? [];\n}\n\n/**\n * Get all define-entity entries for a specific entity name.\n */\nexport function getDefineEntriesForEntity(\n  index: WorkspaceIndex,\n  entityName: string,\n): IndexedEntry<SchemaEntry>[] {\n  return index.defineEntitiesByName.get(entityName) ?? [];\n}\n\n/**\n * Get all alter-entity entries for a specific entity name.\n */\nexport function getAlterEntriesForEntity(\n  index: WorkspaceIndex,\n  entityName: string,\n): IndexedEntry<SchemaEntry>[] {\n  return index.alterEntitiesByName.get(entityName) ?? [];\n}\n\n/**\n * Get all entries that reference a specific link ID.\n */\nexport function getEntriesReferencingLink(\n  index: WorkspaceIndex,\n  linkId: string,\n): IndexedEntry<Entry>[] {\n  return index.entriesReferencingLink.get(linkId) ?? [];\n}\n"],"mappings":";;;;AAgFA,SAAS,qBAA4C;AACnD,QAAO;EACL,iBAAiB,EAAE;EACnB,eAAe,EAAE;EACjB,kBAAkB,EAAE;EACpB,kBAAkB,EAAE;EACpB,sCAAsB,IAAI,KAAK;EAC/B,qCAAqB,IAAI,KAAK;EAC9B,mCAAmB,IAAI,KAAK;EAC5B,mCAAmB,IAAI,KAAK;EAC5B,wCAAwB,IAAI,KAAK;EACjC,oCAAoB,IAAI,KAAK;EAC9B;;;;;AAMH,SAAS,cAAoB,KAAkB,KAAQ,OAAgB;CACrE,MAAM,MAAM,IAAI,IAAI,IAAI;AACxB,KAAI,IACF,KAAI,KAAK,MAAM;KAEf,KAAI,IAAI,KAAK,CAAC,MAAM,CAAC;;;;;AAOzB,SAAS,qBAAqB,OAAwB;CACpD,MAAMA,UAAoB,EAAE;AAE5B,KAAI,MAAM,SAAS,oBAAoB,MAAM,SAAS,kBACpD,MAAK,MAAM,KAAK,MAAM,UAAU;EAC9B,MAAM,UAAU,EAAE,MAAM;AACxB,MAAI,QAAQ,SAAS,aACnB,SAAQ,KAAK,QAAQ,KAAK,GAAG;WACpB,QAAQ,SAAS,eAC1B;QAAK,MAAM,WAAW,QAAQ,SAC5B,KAAI,QAAQ,SAAS,OACnB,SAAQ,KAAK,QAAQ,GAAG;;;UAKvB,MAAM,SAAS,mBAAmB;AAE3C,UAAQ,KAAK,MAAM,OAAO,OAAO,GAAG;AAEpC,OAAK,MAAM,KAAK,MAAM,UAAU;GAC9B,MAAM,UAAU,EAAE,MAAM;AACxB,OAAI,QAAQ,SAAS,aACnB,SAAQ,KAAK,QAAQ,KAAK,GAAG;YACpB,QAAQ,SAAS,eAC1B;SAAK,MAAM,WAAW,QAAQ,SAC5B,KAAI,QAAQ,SAAS,OACnB,SAAQ,KAAK,QAAQ,GAAG;;;;AAOlC,QAAO;;;;;;;;AAST,SAAgB,oBAAoB,WAAsC;CACxE,MAAM,UAAU,oBAAoB;AAGpC,MAAK,MAAM,SAAS,UAAU,WAAW,EAAE;EACzC,MAAM,OAAO,MAAM;EACnB,MAAM,YAAY,MAAM;AAExB,OAAK,MAAM,SAAS,MAAM,IAAI,SAAS;GACrC,MAAM,UAAU;IAAE;IAAO;IAAO;IAAM;IAAW;AAGjD,WAAQ,MAAM,MAAd;IACE,KAAK,kBAAkB;KACrB,MAAM,kBAAkB;AACxB,aAAQ,gBAAgB,KAAK,gBAAgB;KAG7C,MAAM,aAAa,MAAM,OAAO;AAChC,mBAAc,QAAQ,mBAAmB,YAAY,gBAAgB;AACrE,mBAAc,QAAQ,oBAAoB,YAAY,QAA+B;AAGrF,SAAI,MAAM,OAAO,KACf,SAAQ,kBAAkB,IAAI,MAAM,OAAO,KAAK,IAAI,gBAAgB;AAItE,UAAK,MAAM,UAAU,qBAAqB,MAAM,CAC9C,eAAc,QAAQ,wBAAwB,QAAQ,QAA+B;AAEvF;;IAGF,KAAK,gBAAgB;KACnB,MAAM,gBAAgB;AACtB,aAAQ,cAAc,KAAK,cAAc;KAEzC,MAAM,aAAa,MAAM,OAAO,WAAW;AAC3C,SAAI,MAAM,OAAO,cAAc,gBAC7B,eAAc,QAAQ,sBAAsB,YAAY,cAAc;SAEtE,eAAc,QAAQ,qBAAqB,YAAY,cAAc;AAEvE;;IAGF,KAAK,mBAAmB;KACtB,MAAM,mBAAmB;AACzB,aAAQ,iBAAiB,KAAK,iBAAiB;AAG/C,UAAK,MAAM,UAAU,qBAAqB,MAAM,CAC9C,eAAc,QAAQ,wBAAwB,QAAQ,QAA+B;AAEvF;;IAGF,KAAK,mBAAmB;KACtB,MAAM,mBAAmB;AACzB,aAAQ,iBAAiB,KAAK,iBAAiB;AAG/C,UAAK,MAAM,UAAU,qBAAqB,MAAM,CAC9C,eAAc,QAAQ,wBAAwB,QAAQ,QAA+B;AAEvF;;;;;AAMR,QAAO"}

package/dist/commands/actualize.d.ts

@@ -0,0 +1,113 @@
+import { Workspace } from "../model/workspace.js";
+import { ChangeMarker, ChangeTracker } from "../services/change-tracker/change-tracker.js";
+
+//#region src/commands/actualize.d.ts
+
+/**
+ * Default instructions template for actualization.
+ * Uses placeholders: {file}, {linkId}, {checkpoint}, {timestamp}
+ */
+declare const DEFAULT_INSTRUCTIONS_TEMPLATE = "1. Update only the synthesis content directly below the ```thalo block in {file}\n2. Do NOT modify the ```thalo block or the define-synthesis entry; the only change inside the block is appending the actualize entry in step 4\n3. Place output BEFORE any subsequent ```thalo blocks\n4. Append to the thalo block: {timestamp} actualize-synthesis ^{linkId}\n   with metadata: checkpoint: \"{checkpoint}\"";
+/**
+ * Parameters for generating instructions.
+ */
+interface InstructionsParams {
+  /** Relative file path */
+  file: string;
+  /** Link ID for the synthesis */
+  linkId: string;
+  /** Checkpoint value */
+  checkpoint: string;
+  /** Current timestamp for the actualize entry */
+  timestamp: string;
+}
+/**
+ * Generate instructions from a template with placeholder substitution.
+ */
+declare function generateInstructions(template: string, params: InstructionsParams): string;
+/**
+ * Generate a timestamp string suitable for thalo entries.
+ * Format: ISO 8601 with minute precision (e.g., "2026-01-13T10:30Z")
+ */
+declare function generateTimestamp(date?: Date): string;
+/**
+ * Information about a matching entry for a synthesis.
+ */
+interface ActualizeEntryInfo {
+  /** File path containing the entry */
+  file: string;
+  /** Formatted timestamp string */
+  timestamp: string;
+  /** Entity type */
+  entity: string;
+  /** Entry title */
+  title: string;
+  /** Link ID if present */
+  linkId: string | null;
+  /** Tags on the entry */
+  tags: string[];
+  /** Raw source text of the entry */
+  rawText: string;
+}
+/**
+ * Information about a synthesis and its pending updates.
+ */
+interface SynthesisOutputInfo {
+  /** File path containing the synthesis definition */
+  file: string;
+  /** Title of the synthesis */
+  title: string;
+  /** Link ID for the synthesis */
+  linkId: string;
+  /** Source queries as formatted strings */
+  sources: string[];
+  /** Last checkpoint marker, or null if never actualized */
+  lastCheckpoint: ChangeMarker | null;
+  /** The prompt text for the LLM */
+  prompt: string | null;
+  /** Entries that have changed since last checkpoint */
+  entries: ActualizeEntryInfo[];
+  /** Current checkpoint marker to store */
+  currentCheckpoint: ChangeMarker;
+  /** Whether the synthesis is up to date (no new entries) */
+  isUpToDate: boolean;
+}
+/**
+ * Result of running the actualize command.
+ */
+interface ActualizeResult {
+  /** Information about each synthesis in the workspace */
+  syntheses: SynthesisOutputInfo[];
+  /** Type of change tracker used */
+  trackerType: "git" | "ts";
+  /** Link IDs that were not found (when filtering) */
+  notFoundLinkIds: string[];
+}
+/**
+ * Options for running the actualize command.
+ */
+interface RunActualizeOptions {
+  /** Only process syntheses with these link IDs (optional ^ prefix is stripped) */
+  targetLinkIds?: string[];
+  /**
+   * Pre-created change tracker to use.
+   * If not provided, a browser-safe TimestampChangeTracker is used.
+   * CLI should pass a GitChangeTracker for proper git-based tracking.
+   */
+  tracker?: ChangeTracker;
+}
+/**
+ * Parse link IDs, stripping optional ^ prefix.
+ */
+declare function parseLinkIds(ids: string[]): string[];
+/**
+ * Run the actualize command on a workspace.
+ *
+ * @param workspace - The workspace containing synthesis definitions
+ * @param options - Actualize options
+ * @returns Structured actualize results
+ */
+declare function runActualize(workspace: Workspace, options?: RunActualizeOptions): Promise<ActualizeResult>;
+//#endregion
+export { ActualizeEntryInfo, ActualizeResult, DEFAULT_INSTRUCTIONS_TEMPLATE, InstructionsParams, RunActualizeOptions, SynthesisOutputInfo, generateInstructions, generateTimestamp, parseLinkIds, runActualize };
+//# sourceMappingURL=actualize.d.ts.map

package/dist/commands/actualize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actualize.d.ts","names":[],"sources":["../../src/commands/actualize.ts"],"sourcesContent":[],"mappings":";;;;;AAqDA;AAYA;AAWA;AAoBA;AAUkB,cA5EL,6BAAA,GA4EK,kZAAA;;;;AAcD,UAjFA,kBAAA,CAmFJ;EAUI;EAcD,IAAA,EAAA,MAAA;EAsFM;EACT,MAAA,EAAA,MAAA;EACF;EACA,UAAA,EAAA,MAAA;EAAR;EAAO,SAAA,EAAA,MAAA;;;;;iBAtLM,oBAAA,2BAA+C;;;;;iBAY/C,iBAAA,QAAwB;;;;UAWvB,kBAAA;;;;;;;;;;;;;;;;;;;UAoBA,mBAAA;;;;;;;;;;kBAUC;;;;WAIP;;qBAEU;;;;;;;UAQJ,eAAA;;aAEJ;;;;;;;;;UAUI,mBAAA;;;;;;;;YAQL;;;;;iBAMI,YAAA;;;;;;;;iBAsFM,YAAA,YACT,qBACF,sBACR,QAAQ"}

package/dist/commands/actualize.js

@@ -0,0 +1,111 @@
+import { formatQuery } from "../services/query.js";
+import { TimestampChangeTracker } from "../services/change-tracker/timestamp-tracker.js";
+import { parseCheckpoint } from "../services/change-tracker/change-tracker.js";
+import { formatTimestamp } from "../formatters.js";
+import { findAllSyntheses, findEntryFile, findLatestActualize, getEntrySourceText } from "../services/synthesis.js";
+
+//#region src/commands/actualize.ts
+/**
+* Default instructions template for actualization.
+* Uses placeholders: {file}, {linkId}, {checkpoint}, {timestamp}
+*/
+const DEFAULT_INSTRUCTIONS_TEMPLATE = `1. Update only the synthesis content directly below the \`\`\`thalo block in {file}
+2. Do NOT modify the \`\`\`thalo block or the define-synthesis entry; the only change inside the block is appending the actualize entry in step 4
+3. Place output BEFORE any subsequent \`\`\`thalo blocks
+4. Append to the thalo block: {timestamp} actualize-synthesis ^{linkId}
+   with metadata: checkpoint: "{checkpoint}"`;
+/**
+* Generate instructions from a template with placeholder substitution.
+*/
+function generateInstructions(template, params) {
+	return template.replace(/\{file\}/g, params.file).replace(/\{linkId\}/g, params.linkId).replace(/\{checkpoint\}/g, params.checkpoint).replace(/\{timestamp\}/g, params.timestamp);
+}
+/**
+* Generate a timestamp string suitable for thalo entries.
+* Format: ISO 8601 with minute precision (e.g., "2026-01-13T10:30Z")
+*/
+function generateTimestamp(date = /* @__PURE__ */ new Date()) {
+	return date.toISOString().slice(0, 16) + "Z";
+}
+/**
+* Parse link IDs, stripping optional ^ prefix.
+*/
+function parseLinkIds(ids) {
+	return ids.map((id) => id.startsWith("^") ? id.slice(1) : id);
+}
+/**
+* Get the change marker from an actualize entry.
+* Reads from the checkpoint metadata field.
+*/
+function getActualizeMarker(actualize) {
+	if (!actualize) return null;
+	return parseCheckpoint(actualize.entry.metadata.find((m) => m.key.value === "checkpoint")?.value.raw);
+}
+/**
+* Convert an InstanceEntry to ActualizeEntryInfo.
+*/
+function toActualizeEntryInfo(entry, file, workspace) {
+	const model = workspace.getModel(file);
+	const rawText = model ? getEntrySourceText(entry, model.source) : "";
+	return {
+		file,
+		timestamp: formatTimestamp(entry.header.timestamp),
+		entity: entry.header.entity,
+		title: entry.header.title.value,
+		linkId: entry.header.link?.id ?? null,
+		tags: entry.header.tags.map((t) => t.name),
+		rawText
+	};
+}
+/**
+* Process a single synthesis and get its output info.
+*/
+async function processSynthesis(synthesis, workspace, tracker) {
+	const lastCheckpoint = getActualizeMarker(findLatestActualize(workspace, synthesis.linkId));
+	const { entries: changedEntries, currentMarker } = await tracker.getChangedEntries(workspace, synthesis.sources, lastCheckpoint);
+	const entries = [];
+	for (const entry of changedEntries) {
+		const file = findEntryFile(workspace, entry);
+		if (file) entries.push(toActualizeEntryInfo(entry, file, workspace));
+	}
+	return {
+		file: synthesis.file,
+		title: synthesis.title,
+		linkId: synthesis.linkId,
+		sources: synthesis.sources.map(formatQuery),
+		lastCheckpoint,
+		prompt: synthesis.prompt,
+		entries,
+		currentCheckpoint: currentMarker,
+		isUpToDate: entries.length === 0
+	};
+}
+/**
+* Run the actualize command on a workspace.
+*
+* @param workspace - The workspace containing synthesis definitions
+* @param options - Actualize options
+* @returns Structured actualize results
+*/
+async function runActualize(workspace, options = {}) {
+	const { targetLinkIds, tracker: providedTracker } = options;
+	const tracker = providedTracker ?? new TimestampChangeTracker();
+	let syntheses = findAllSyntheses(workspace);
+	const notFoundLinkIds = [];
+	if (targetLinkIds && targetLinkIds.length > 0) {
+		const normalizedIds = parseLinkIds(targetLinkIds);
+		const filtered = syntheses.filter((s) => normalizedIds.includes(s.linkId));
+		const foundIds = new Set(filtered.map((s) => s.linkId));
+		for (const id of normalizedIds) if (!foundIds.has(id)) notFoundLinkIds.push(id);
+		syntheses = filtered;
+	}
+	return {
+		syntheses: await Promise.all(syntheses.map((s) => processSynthesis(s, workspace, tracker))),
+		trackerType: tracker.type,
+		notFoundLinkIds
+	};
+}
+
+//#endregion
+export { DEFAULT_INSTRUCTIONS_TEMPLATE, generateInstructions, generateTimestamp, parseLinkIds, runActualize };
+//# sourceMappingURL=actualize.js.map

package/dist/commands/actualize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actualize.js","names":["entries: ActualizeEntryInfo[]","notFoundLinkIds: string[]"],"sources":["../../src/commands/actualize.ts"],"sourcesContent":["/**\n * Actualize command - finds syntheses and returns information about pending updates.\n * Uses git-based or timestamp-based change tracking to identify modified entries.\n */\n\nimport type { Workspace } from \"../model/workspace.js\";\nimport type { InstanceEntry } from \"../ast/ast-types.js\";\nimport {\n  findAllSyntheses,\n  findLatestActualize,\n  findEntryFile,\n  getEntrySourceText,\n  type SynthesisInfo,\n  type ActualizeInfo,\n} from \"../services/synthesis.js\";\nimport { formatQuery } from \"../services/query.js\";\nimport { formatTimestamp } from \"../formatters.js\";\n// Import only browser-safe parts - types and timestamp tracker\n// The git tracker must be passed in from the caller (CLI) to avoid Node.js deps\nimport {\n  parseCheckpoint,\n  type ChangeTracker,\n  type ChangeMarker,\n} from \"../services/change-tracker/change-tracker.js\";\nimport { TimestampChangeTracker } from \"../services/change-tracker/timestamp-tracker.js\";\n\n/**\n * Default instructions template for actualization.\n * Uses placeholders: {file}, {linkId}, {checkpoint}, {timestamp}\n */\nexport const DEFAULT_INSTRUCTIONS_TEMPLATE = `1. Update only the synthesis content directly below the \\`\\`\\`thalo block in {file}\n2. Do NOT modify the \\`\\`\\`thalo block or the define-synthesis entry; the only change inside the block is appending the actualize entry in step 4\n3. Place output BEFORE any subsequent \\`\\`\\`thalo blocks\n4. Append to the thalo block: {timestamp} actualize-synthesis ^{linkId}\n   with metadata: checkpoint: \"{checkpoint}\"`;\n\n/**\n * Parameters for generating instructions.\n */\nexport interface InstructionsParams {\n  /** Relative file path */\n  file: string;\n  /** Link ID for the synthesis */\n  linkId: string;\n  /** Checkpoint value */\n  checkpoint: string;\n  /** Current timestamp for the actualize entry */\n  timestamp: string;\n}\n\n/**\n * Generate instructions from a template with placeholder substitution.\n */\nexport function generateInstructions(template: string, params: InstructionsParams): string {\n  return template\n    .replace(/\\{file\\}/g, params.file)\n    .replace(/\\{linkId\\}/g, params.linkId)\n    .replace(/\\{checkpoint\\}/g, params.checkpoint)\n    .replace(/\\{timestamp\\}/g, params.timestamp);\n}\n\n/**\n * Generate a timestamp string suitable for thalo entries.\n * Format: ISO 8601 with minute precision (e.g., \"2026-01-13T10:30Z\")\n */\nexport function generateTimestamp(date: Date = new Date()): string {\n  return date.toISOString().slice(0, 16) + \"Z\";\n}\n\n// ===================\n// Types\n// ===================\n\n/**\n * Information about a matching entry for a synthesis.\n */\nexport interface ActualizeEntryInfo {\n  /** File path containing the entry */\n  file: string;\n  /** Formatted timestamp string */\n  timestamp: string;\n  /** Entity type */\n  entity: string;\n  /** Entry title */\n  title: string;\n  /** Link ID if present */\n  linkId: string | null;\n  /** Tags on the entry */\n  tags: string[];\n  /** Raw source text of the entry */\n  rawText: string;\n}\n\n/**\n * Information about a synthesis and its pending updates.\n */\nexport interface SynthesisOutputInfo {\n  /** File path containing the synthesis definition */\n  file: string;\n  /** Title of the synthesis */\n  title: string;\n  /** Link ID for the synthesis */\n  linkId: string;\n  /** Source queries as formatted strings */\n  sources: string[];\n  /** Last checkpoint marker, or null if never actualized */\n  lastCheckpoint: ChangeMarker | null;\n  /** The prompt text for the LLM */\n  prompt: string | null;\n  /** Entries that have changed since last checkpoint */\n  entries: ActualizeEntryInfo[];\n  /** Current checkpoint marker to store */\n  currentCheckpoint: ChangeMarker;\n  /** Whether the synthesis is up to date (no new entries) */\n  isUpToDate: boolean;\n}\n\n/**\n * Result of running the actualize command.\n */\nexport interface ActualizeResult {\n  /** Information about each synthesis in the workspace */\n  syntheses: SynthesisOutputInfo[];\n  /** Type of change tracker used */\n  trackerType: \"git\" | \"ts\";\n  /** Link IDs that were not found (when filtering) */\n  notFoundLinkIds: string[];\n}\n\n/**\n * Options for running the actualize command.\n */\nexport interface RunActualizeOptions {\n  /** Only process syntheses with these link IDs (optional ^ prefix is stripped) */\n  targetLinkIds?: string[];\n  /**\n   * Pre-created change tracker to use.\n   * If not provided, a browser-safe TimestampChangeTracker is used.\n   * CLI should pass a GitChangeTracker for proper git-based tracking.\n   */\n  tracker?: ChangeTracker;\n}\n\n/**\n * Parse link IDs, stripping optional ^ prefix.\n */\nexport function parseLinkIds(ids: string[]): string[] {\n  return ids.map((id) => (id.startsWith(\"^\") ? id.slice(1) : id));\n}\n\n/**\n * Get the change marker from an actualize entry.\n * Reads from the checkpoint metadata field.\n */\nfunction getActualizeMarker(actualize: ActualizeInfo | null): ChangeMarker | null {\n  if (!actualize) {\n    return null;\n  }\n  const checkpoint = actualize.entry.metadata.find((m) => m.key.value === \"checkpoint\");\n  return parseCheckpoint(checkpoint?.value.raw);\n}\n\n/**\n * Convert an InstanceEntry to ActualizeEntryInfo.\n */\nfunction toActualizeEntryInfo(\n  entry: InstanceEntry,\n  file: string,\n  workspace: Workspace,\n): ActualizeEntryInfo {\n  const model = workspace.getModel(file);\n  const rawText = model ? getEntrySourceText(entry, model.source) : \"\";\n\n  return {\n    file,\n    timestamp: formatTimestamp(entry.header.timestamp),\n    entity: entry.header.entity,\n    title: entry.header.title.value,\n    linkId: entry.header.link?.id ?? null,\n    tags: entry.header.tags.map((t) => t.name),\n    rawText,\n  };\n}\n\n/**\n * Process a single synthesis and get its output info.\n */\nasync function processSynthesis(\n  synthesis: SynthesisInfo,\n  workspace: Workspace,\n  tracker: ChangeTracker,\n): Promise<SynthesisOutputInfo> {\n  // Find latest actualize entry and its checkpoint\n  const lastActualize = findLatestActualize(workspace, synthesis.linkId);\n  const lastCheckpoint = getActualizeMarker(lastActualize);\n\n  // Get changed entries using the tracker\n  const { entries: changedEntries, currentMarker } = await tracker.getChangedEntries(\n    workspace,\n    synthesis.sources,\n    lastCheckpoint,\n  );\n\n  // Convert entries to ActualizeEntryInfo\n  const entries: ActualizeEntryInfo[] = [];\n  for (const entry of changedEntries) {\n    const file = findEntryFile(workspace, entry);\n    if (file) {\n      entries.push(toActualizeEntryInfo(entry, file, workspace));\n    }\n  }\n\n  return {\n    file: synthesis.file,\n    title: synthesis.title,\n    linkId: synthesis.linkId,\n    sources: synthesis.sources.map(formatQuery),\n    lastCheckpoint,\n    prompt: synthesis.prompt,\n    entries,\n    currentCheckpoint: currentMarker,\n    isUpToDate: entries.length === 0,\n  };\n}\n\n/**\n * Run the actualize command on a workspace.\n *\n * @param workspace - The workspace containing synthesis definitions\n * @param options - Actualize options\n * @returns Structured actualize results\n */\nexport async function runActualize(\n  workspace: Workspace,\n  options: RunActualizeOptions = {},\n): Promise<ActualizeResult> {\n  const { targetLinkIds, tracker: providedTracker } = options;\n\n  // Use provided tracker or fall back to browser-safe timestamp tracker\n  const tracker = providedTracker ?? new TimestampChangeTracker();\n\n  // Find all synthesis definitions\n  let syntheses = findAllSyntheses(workspace);\n  const notFoundLinkIds: string[] = [];\n\n  // Filter to targets if specified\n  if (targetLinkIds && targetLinkIds.length > 0) {\n    const normalizedIds = parseLinkIds(targetLinkIds);\n    const filtered = syntheses.filter((s) => normalizedIds.includes(s.linkId));\n\n    // Track which IDs weren't found\n    const foundIds = new Set(filtered.map((s) => s.linkId));\n    for (const id of normalizedIds) {\n      if (!foundIds.has(id)) {\n        notFoundLinkIds.push(id);\n      }\n    }\n\n    syntheses = filtered;\n  }\n\n  // Process each synthesis\n  const synthesisOutputs: SynthesisOutputInfo[] = await Promise.all(\n    syntheses.map((s) => processSynthesis(s, workspace, tracker)),\n  );\n\n  return {\n    syntheses: synthesisOutputs,\n    trackerType: tracker.type,\n    notFoundLinkIds,\n  };\n}\n"],"mappings":";;;;;;;;;;;AA8BA,MAAa,gCAAgC;;;;;;;;AAuB7C,SAAgB,qBAAqB,UAAkB,QAAoC;AACzF,QAAO,SACJ,QAAQ,aAAa,OAAO,KAAK,CACjC,QAAQ,eAAe,OAAO,OAAO,CACrC,QAAQ,mBAAmB,OAAO,WAAW,CAC7C,QAAQ,kBAAkB,OAAO,UAAU;;;;;;AAOhD,SAAgB,kBAAkB,uBAAa,IAAI,MAAM,EAAU;AACjE,QAAO,KAAK,aAAa,CAAC,MAAM,GAAG,GAAG,GAAG;;;;;AAgF3C,SAAgB,aAAa,KAAyB;AACpD,QAAO,IAAI,KAAK,OAAQ,GAAG,WAAW,IAAI,GAAG,GAAG,MAAM,EAAE,GAAG,GAAI;;;;;;AAOjE,SAAS,mBAAmB,WAAsD;AAChF,KAAI,CAAC,UACH,QAAO;AAGT,QAAO,gBADY,UAAU,MAAM,SAAS,MAAM,MAAM,EAAE,IAAI,UAAU,aAAa,EAClD,MAAM,IAAI;;;;;AAM/C,SAAS,qBACP,OACA,MACA,WACoB;CACpB,MAAM,QAAQ,UAAU,SAAS,KAAK;CACtC,MAAM,UAAU,QAAQ,mBAAmB,OAAO,MAAM,OAAO,GAAG;AAElE,QAAO;EACL;EACA,WAAW,gBAAgB,MAAM,OAAO,UAAU;EAClD,QAAQ,MAAM,OAAO;EACrB,OAAO,MAAM,OAAO,MAAM;EAC1B,QAAQ,MAAM,OAAO,MAAM,MAAM;EACjC,MAAM,MAAM,OAAO,KAAK,KAAK,MAAM,EAAE,KAAK;EAC1C;EACD;;;;;AAMH,eAAe,iBACb,WACA,WACA,SAC8B;CAG9B,MAAM,iBAAiB,mBADD,oBAAoB,WAAW,UAAU,OAAO,CACd;CAGxD,MAAM,EAAE,SAAS,gBAAgB,kBAAkB,MAAM,QAAQ,kBAC/D,WACA,UAAU,SACV,eACD;CAGD,MAAMA,UAAgC,EAAE;AACxC,MAAK,MAAM,SAAS,gBAAgB;EAClC,MAAM,OAAO,cAAc,WAAW,MAAM;AAC5C,MAAI,KACF,SAAQ,KAAK,qBAAqB,OAAO,MAAM,UAAU,CAAC;;AAI9D,QAAO;EACL,MAAM,UAAU;EAChB,OAAO,UAAU;EACjB,QAAQ,UAAU;EAClB,SAAS,UAAU,QAAQ,IAAI,YAAY;EAC3C;EACA,QAAQ,UAAU;EAClB;EACA,mBAAmB;EACnB,YAAY,QAAQ,WAAW;EAChC;;;;;;;;;AAUH,eAAsB,aACpB,WACA,UAA+B,EAAE,EACP;CAC1B,MAAM,EAAE,eAAe,SAAS,oBAAoB;CAGpD,MAAM,UAAU,mBAAmB,IAAI,wBAAwB;CAG/D,IAAI,YAAY,iBAAiB,UAAU;CAC3C,MAAMC,kBAA4B,EAAE;AAGpC,KAAI,iBAAiB,cAAc,SAAS,GAAG;EAC7C,MAAM,gBAAgB,aAAa,cAAc;EACjD,MAAM,WAAW,UAAU,QAAQ,MAAM,cAAc,SAAS,EAAE,OAAO,CAAC;EAG1E,MAAM,WAAW,IAAI,IAAI,SAAS,KAAK,MAAM,EAAE,OAAO,CAAC;AACvD,OAAK,MAAM,MAAM,cACf,KAAI,CAAC,SAAS,IAAI,GAAG,CACnB,iBAAgB,KAAK,GAAG;AAI5B,cAAY;;AAQd,QAAO;EACL,WAL8C,MAAM,QAAQ,IAC5D,UAAU,KAAK,MAAM,iBAAiB,GAAG,WAAW,QAAQ,CAAC,CAC9D;EAIC,aAAa,QAAQ;EACrB;EACD"}