@rejot-dev/thalo 0.0.0

package/dist/checker/rules/rules.js

@@ -0,0 +1,102 @@
+import { unknownEntityRule } from "./unknown-entity.js";
+import { missingRequiredFieldRule } from "./missing-required-field.js";
+import { unknownFieldRule } from "./unknown-field.js";
+import { invalidFieldTypeRule } from "./invalid-field-type.js";
+import { missingRequiredSectionRule } from "./missing-required-section.js";
+import { unknownSectionRule } from "./unknown-section.js";
+import { unresolvedLinkRule } from "./unresolved-link.js";
+import { duplicateLinkIdRule } from "./duplicate-link-id.js";
+import { duplicateEntityDefinitionRule } from "./duplicate-entity-definition.js";
+import { alterUndefinedEntityRule } from "./alter-undefined-entity.js";
+import { alterBeforeDefineRule } from "./alter-before-define.js";
+import { duplicateFieldInSchemaRule } from "./duplicate-field-in-schema.js";
+import { duplicateSectionInSchemaRule } from "./duplicate-section-in-schema.js";
+import { removeUndefinedFieldRule } from "./remove-undefined-field.js";
+import { removeUndefinedSectionRule } from "./remove-undefined-section.js";
+import { invalidDefaultValueRule } from "./invalid-default-value.js";
+import { defineEntityRequiresSectionRule } from "./define-entity-requires-section.js";
+import { duplicateMetadataKeyRule } from "./duplicate-metadata-key.js";
+import { emptyRequiredValueRule } from "./empty-required-value.js";
+import { invalidDateRangeValueRule } from "./invalid-date-range-value.js";
+import { duplicateSectionHeadingRule } from "./duplicate-section-heading.js";
+import { emptySectionRule } from "./empty-section.js";
+import { updateWithoutCreateRule } from "./update-without-create.js";
+import { timestampOutOfOrderRule } from "./timestamp-out-of-order.js";
+import { createRequiresSectionRule } from "./create-requires-section.js";
+import { duplicateTimestampRule } from "./duplicate-timestamp.js";
+import { missingTitleRule } from "./missing-title.js";
+import { synthesisMissingSourcesRule } from "./synthesis-missing-sources.js";
+import { synthesisMissingPromptRule } from "./synthesis-missing-prompt.js";
+import { synthesisEmptyQueryRule } from "./synthesis-empty-query.js";
+import { synthesisUnknownQueryEntityRule } from "./synthesis-unknown-query-entity.js";
+import { actualizeUnresolvedTargetRule } from "./actualize-unresolved-target.js";
+import { actualizeMissingUpdatedRule } from "./actualize-missing-updated.js";
+
+//#region src/checker/rules/rules.ts
+/**
+* Display order and labels for rule categories
+*/
+const RULE_CATEGORIES = {
+	instance: {
+		order: 1,
+		label: "Instance Entry Rules"
+	},
+	link: {
+		order: 2,
+		label: "Link Rules"
+	},
+	schema: {
+		order: 3,
+		label: "Schema Definition Rules"
+	},
+	metadata: {
+		order: 4,
+		label: "Metadata Value Rules"
+	},
+	content: {
+		order: 5,
+		label: "Content Rules"
+	}
+};
+/**
+* All available validation rules
+*/
+const allRules = [
+	unknownEntityRule,
+	missingRequiredFieldRule,
+	unknownFieldRule,
+	invalidFieldTypeRule,
+	missingRequiredSectionRule,
+	unknownSectionRule,
+	unresolvedLinkRule,
+	duplicateLinkIdRule,
+	duplicateEntityDefinitionRule,
+	alterUndefinedEntityRule,
+	alterBeforeDefineRule,
+	duplicateFieldInSchemaRule,
+	duplicateSectionInSchemaRule,
+	removeUndefinedFieldRule,
+	removeUndefinedSectionRule,
+	invalidDefaultValueRule,
+	defineEntityRequiresSectionRule,
+	duplicateMetadataKeyRule,
+	emptyRequiredValueRule,
+	invalidDateRangeValueRule,
+	duplicateSectionHeadingRule,
+	emptySectionRule,
+	updateWithoutCreateRule,
+	timestampOutOfOrderRule,
+	createRequiresSectionRule,
+	duplicateTimestampRule,
+	missingTitleRule,
+	synthesisMissingSourcesRule,
+	synthesisMissingPromptRule,
+	synthesisEmptyQueryRule,
+	synthesisUnknownQueryEntityRule,
+	actualizeUnresolvedTargetRule,
+	actualizeMissingUpdatedRule
+];
+
+//#endregion
+export { RULE_CATEGORIES, allRules };
+//# sourceMappingURL=rules.js.map

package/dist/checker/rules/rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.js","names":["RULE_CATEGORIES: Record<RuleCategory, { order: number; label: string }>","allRules: Rule[]"],"sources":["../../../src/checker/rules/rules.ts"],"sourcesContent":["/**\n * Severity levels for diagnostics\n */\nexport type Severity = \"error\" | \"warning\" | \"info\" | \"off\";\n\n/**\n * Rule categories for grouping related rules\n */\nexport type RuleCategory = \"instance\" | \"link\" | \"schema\" | \"metadata\" | \"content\";\n\n/**\n * Display order and labels for rule categories\n */\nexport const RULE_CATEGORIES: Record<RuleCategory, { order: number; label: string }> = {\n  instance: { order: 1, label: \"Instance Entry Rules\" },\n  link: { order: 2, label: \"Link Rules\" },\n  schema: { order: 3, label: \"Schema Definition Rules\" },\n  metadata: { order: 4, label: \"Metadata Value Rules\" },\n  content: { order: 5, label: \"Content Rules\" },\n};\n\n/**\n * Rule scope - determines when a rule needs to re-run.\n *\n * - \"entry\": Rule only looks at individual entries, can run incrementally on changed entries\n * - \"document\": Rule looks at entries within a single document, runs on full document\n * - \"workspace\": Rule looks across multiple documents, runs on full workspace\n */\nexport type RuleScope = \"entry\" | \"document\" | \"workspace\";\n\n/**\n * Dependency declaration for a rule.\n * Used for incremental checking to determine when a rule needs to re-run.\n */\nexport interface RuleDependencies {\n  /** Rule scope - determines when rule needs to re-run */\n  scope: RuleScope;\n  /** Rule needs schema registry data */\n  schemas?: boolean;\n  /** Rule needs link index data */\n  links?: boolean;\n  /** Entity names this rule cares about (for targeted invalidation) */\n  entities?: \"all\" | string[];\n}\n\n/**\n * A validation rule\n */\nexport interface Rule {\n  /** Unique rule code (e.g., \"unknown-entity\") */\n  code: string;\n  /** Human-readable rule name */\n  name: string;\n  /** Short description of what this rule checks */\n  description: string;\n  /** Category for grouping related rules */\n  category: RuleCategory;\n  /** Default severity for this rule */\n  defaultSeverity: Severity;\n\n  /**\n   * Dependency declaration for incremental checking.\n   */\n  dependencies: RuleDependencies;\n\n  /**\n   * Visitor-based implementation.\n   * Allows single-pass checking with other rules.\n   */\n  visitor: import(\"../visitor.js\").RuleVisitor;\n}\n\n// Existing rules\nimport { unknownEntityRule } from \"./unknown-entity.js\";\nimport { missingRequiredFieldRule } from \"./missing-required-field.js\";\nimport { unknownFieldRule } from \"./unknown-field.js\";\nimport { invalidFieldTypeRule } from \"./invalid-field-type.js\";\nimport { missingRequiredSectionRule } from \"./missing-required-section.js\";\nimport { unknownSectionRule } from \"./unknown-section.js\";\nimport { unresolvedLinkRule } from \"./unresolved-link.js\";\nimport { duplicateLinkIdRule } from \"./duplicate-link-id.js\";\n\n// Schema definition rules\nimport { duplicateEntityDefinitionRule } from \"./duplicate-entity-definition.js\";\nimport { alterUndefinedEntityRule } from \"./alter-undefined-entity.js\";\nimport { alterBeforeDefineRule } from \"./alter-before-define.js\";\nimport { duplicateFieldInSchemaRule } from \"./duplicate-field-in-schema.js\";\nimport { duplicateSectionInSchemaRule } from \"./duplicate-section-in-schema.js\";\nimport { removeUndefinedFieldRule } from \"./remove-undefined-field.js\";\nimport { removeUndefinedSectionRule } from \"./remove-undefined-section.js\";\nimport { invalidDefaultValueRule } from \"./invalid-default-value.js\";\nimport { defineEntityRequiresSectionRule } from \"./define-entity-requires-section.js\";\n\n// Metadata value rules\nimport { duplicateMetadataKeyRule } from \"./duplicate-metadata-key.js\";\nimport { emptyRequiredValueRule } from \"./empty-required-value.js\";\nimport { invalidDateRangeValueRule } from \"./invalid-date-range-value.js\";\n\n// Content/section rules\nimport { duplicateSectionHeadingRule } from \"./duplicate-section-heading.js\";\nimport { emptySectionRule } from \"./empty-section.js\";\n\n// Instance entry rules\nimport { updateWithoutCreateRule } from \"./update-without-create.js\";\nimport { timestampOutOfOrderRule } from \"./timestamp-out-of-order.js\";\nimport { createRequiresSectionRule } from \"./create-requires-section.js\";\nimport { duplicateTimestampRule } from \"./duplicate-timestamp.js\";\n\n// Style rules\nimport { missingTitleRule } from \"./missing-title.js\";\n\n// Synthesis rules\nimport { synthesisMissingSourcesRule } from \"./synthesis-missing-sources.js\";\nimport { synthesisMissingPromptRule } from \"./synthesis-missing-prompt.js\";\nimport { synthesisEmptyQueryRule } from \"./synthesis-empty-query.js\";\nimport { synthesisUnknownQueryEntityRule } from \"./synthesis-unknown-query-entity.js\";\nimport { actualizeUnresolvedTargetRule } from \"./actualize-unresolved-target.js\";\nimport { actualizeMissingUpdatedRule } from \"./actualize-missing-updated.js\";\n\n/**\n * All available validation rules\n */\nexport const allRules: Rule[] = [\n  // Existing rules\n  unknownEntityRule,\n  missingRequiredFieldRule,\n  unknownFieldRule,\n  invalidFieldTypeRule,\n  missingRequiredSectionRule,\n  unknownSectionRule,\n  unresolvedLinkRule,\n  duplicateLinkIdRule,\n\n  // Schema definition rules\n  duplicateEntityDefinitionRule,\n  alterUndefinedEntityRule,\n  alterBeforeDefineRule,\n  duplicateFieldInSchemaRule,\n  duplicateSectionInSchemaRule,\n  removeUndefinedFieldRule,\n  removeUndefinedSectionRule,\n  invalidDefaultValueRule,\n  defineEntityRequiresSectionRule,\n\n  // Metadata value rules\n  duplicateMetadataKeyRule,\n  emptyRequiredValueRule,\n  invalidDateRangeValueRule,\n\n  // Content/section rules\n  duplicateSectionHeadingRule,\n  emptySectionRule,\n\n  // Instance entry rules\n  updateWithoutCreateRule,\n  timestampOutOfOrderRule,\n  createRequiresSectionRule,\n  duplicateTimestampRule,\n\n  // Style rules\n  missingTitleRule,\n\n  // Synthesis rules\n  synthesisMissingSourcesRule,\n  synthesisMissingPromptRule,\n  synthesisEmptyQueryRule,\n  synthesisUnknownQueryEntityRule,\n  actualizeUnresolvedTargetRule,\n  actualizeMissingUpdatedRule,\n];\n\n/**\n * Get a rule by code\n */\nexport function getRule(code: string): Rule | undefined {\n  return allRules.find((r) => r.code === code);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAaA,MAAaA,kBAA0E;CACrF,UAAU;EAAE,OAAO;EAAG,OAAO;EAAwB;CACrD,MAAM;EAAE,OAAO;EAAG,OAAO;EAAc;CACvC,QAAQ;EAAE,OAAO;EAAG,OAAO;EAA2B;CACtD,UAAU;EAAE,OAAO;EAAG,OAAO;EAAwB;CACrD,SAAS;EAAE,OAAO;EAAG,OAAO;EAAiB;CAC9C;;;;AAuGD,MAAaC,WAAmB;CAE9B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CAGA;CACA;CAGA;CACA;CACA;CACA;CAGA;CAGA;CACA;CACA;CACA;CACA;CACA;CACD"}

package/dist/checker/rules/synthesis-empty-query.js

@@ -0,0 +1,35 @@
+//#region src/checker/rules/synthesis-empty-query.ts
+const category = "instance";
+const visitor = { visitSynthesisEntry(entry, ctx) {
+	const title = entry.header.title.value;
+	const sourcesMetadata = entry.metadata.find((m) => m.key.value === "sources");
+	if (!sourcesMetadata) return;
+	const sourcesValue = sourcesMetadata.value;
+	if (sourcesValue.content.type === "quoted_value" && sourcesValue.content.value.trim() === "") ctx.report({
+		message: `Synthesis '${title}' has an empty query. Specify an entity type like 'lore', 'journal', 'opinion', or 'reference'.`,
+		file: ctx.file,
+		location: entry.location,
+		sourceMap: ctx.sourceMap,
+		data: { title }
+	});
+} };
+/**
+* Check that synthesis queries have at least an entity type
+*
+* Note: This rule validates the "sources:" metadata value exists and contains
+* valid query syntax. Query validation is simplified since the full query parsing
+* happens at a different layer.
+*/
+const synthesisEmptyQueryRule = {
+	code: "synthesis-empty-query",
+	name: "Synthesis Empty Query",
+	description: "A synthesis source query must specify an entity type",
+	category,
+	defaultSeverity: "error",
+	dependencies: { scope: "entry" },
+	visitor
+};
+
+//#endregion
+export { synthesisEmptyQueryRule };
+//# sourceMappingURL=synthesis-empty-query.js.map

package/dist/checker/rules/synthesis-empty-query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"synthesis-empty-query.js","names":["category: RuleCategory","visitor: RuleVisitor","synthesisEmptyQueryRule: Rule"],"sources":["../../../src/checker/rules/synthesis-empty-query.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\nimport type { RuleVisitor } from \"../visitor.js\";\n\nconst category: RuleCategory = \"instance\";\n\nconst visitor: RuleVisitor = {\n  visitSynthesisEntry(entry, ctx) {\n    const title = entry.header.title.value;\n    const sourcesMetadata = entry.metadata.find((m) => m.key.value === \"sources\");\n\n    if (!sourcesMetadata) {\n      // Missing sources is handled by synthesis-missing-sources rule\n      return;\n    }\n\n    // Check if sources value is empty or just whitespace\n    const sourcesValue = sourcesMetadata.value;\n    if (sourcesValue.content.type === \"quoted_value\" && sourcesValue.content.value.trim() === \"\") {\n      ctx.report({\n        message: `Synthesis '${title}' has an empty query. Specify an entity type like 'lore', 'journal', 'opinion', or 'reference'.`,\n        file: ctx.file,\n        location: entry.location,\n        sourceMap: ctx.sourceMap,\n        data: { title },\n      });\n    }\n  },\n};\n\n/**\n * Check that synthesis queries have at least an entity type\n *\n * Note: This rule validates the \"sources:\" metadata value exists and contains\n * valid query syntax. Query validation is simplified since the full query parsing\n * happens at a different layer.\n */\nexport const synthesisEmptyQueryRule: Rule = {\n  code: \"synthesis-empty-query\",\n  name: \"Synthesis Empty Query\",\n  description: \"A synthesis source query must specify an entity type\",\n  category,\n  defaultSeverity: \"error\",\n  dependencies: { scope: \"entry\" },\n  visitor,\n};\n"],"mappings":";AAGA,MAAMA,WAAyB;AAE/B,MAAMC,UAAuB,EAC3B,oBAAoB,OAAO,KAAK;CAC9B,MAAM,QAAQ,MAAM,OAAO,MAAM;CACjC,MAAM,kBAAkB,MAAM,SAAS,MAAM,MAAM,EAAE,IAAI,UAAU,UAAU;AAE7E,KAAI,CAAC,gBAEH;CAIF,MAAM,eAAe,gBAAgB;AACrC,KAAI,aAAa,QAAQ,SAAS,kBAAkB,aAAa,QAAQ,MAAM,MAAM,KAAK,GACxF,KAAI,OAAO;EACT,SAAS,cAAc,MAAM;EAC7B,MAAM,IAAI;EACV,UAAU,MAAM;EAChB,WAAW,IAAI;EACf,MAAM,EAAE,OAAO;EAChB,CAAC;GAGP;;;;;;;;AASD,MAAaC,0BAAgC;CAC3C,MAAM;CACN,MAAM;CACN,aAAa;CACb;CACA,iBAAiB;CACjB,cAAc,EAAE,OAAO,SAAS;CAChC;CACD"}

package/dist/checker/rules/synthesis-missing-prompt.js

@@ -0,0 +1,42 @@
+//#region src/checker/rules/synthesis-missing-prompt.ts
+const category = "instance";
+const visitor = { visitSynthesisEntry(entry, ctx) {
+	const title = entry.header.title.value;
+	const linkId = entry.header.linkId.id;
+	const content = entry.content;
+	let hasPromptWithContent = false;
+	if (content) {
+		let foundPromptHeader = false;
+		for (const child of content.children) if (child.type === "markdown_header" && child.text.toLowerCase().includes("prompt")) foundPromptHeader = true;
+		else if (foundPromptHeader && child.type === "content_line") {
+			hasPromptWithContent = true;
+			break;
+		} else if (foundPromptHeader && child.type === "markdown_header") break;
+	}
+	if (!hasPromptWithContent) ctx.report({
+		message: `Synthesis '${title}' is missing a '# Prompt' section. Add instructions for the LLM.`,
+		file: ctx.file,
+		location: entry.location,
+		sourceMap: ctx.sourceMap,
+		data: {
+			title,
+			linkId
+		}
+	});
+} };
+/**
+* Check that define-synthesis entries have a Prompt section
+*/
+const synthesisMissingPromptRule = {
+	code: "synthesis-missing-prompt",
+	name: "Synthesis Missing Prompt",
+	description: "A define-synthesis entry should have a '# Prompt' section with instructions for the LLM",
+	category,
+	defaultSeverity: "warning",
+	dependencies: { scope: "entry" },
+	visitor
+};
+
+//#endregion
+export { synthesisMissingPromptRule };
+//# sourceMappingURL=synthesis-missing-prompt.js.map

package/dist/checker/rules/synthesis-missing-prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"synthesis-missing-prompt.js","names":["category: RuleCategory","visitor: RuleVisitor","synthesisMissingPromptRule: Rule"],"sources":["../../../src/checker/rules/synthesis-missing-prompt.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\nimport type { RuleVisitor } from \"../visitor.js\";\n\nconst category: RuleCategory = \"instance\";\n\nconst visitor: RuleVisitor = {\n  visitSynthesisEntry(entry, ctx) {\n    const title = entry.header.title.value;\n    const linkId = entry.header.linkId.id;\n    const content = entry.content;\n\n    // Check if there's a # Prompt section with content\n    let hasPromptWithContent = false;\n    if (content) {\n      let foundPromptHeader = false;\n      for (const child of content.children) {\n        if (child.type === \"markdown_header\" && child.text.toLowerCase().includes(\"prompt\")) {\n          foundPromptHeader = true;\n        } else if (foundPromptHeader && child.type === \"content_line\") {\n          // Found content after the prompt header\n          hasPromptWithContent = true;\n          break;\n        } else if (foundPromptHeader && child.type === \"markdown_header\") {\n          // Hit another header before finding content - prompt section is empty\n          break;\n        }\n      }\n    }\n\n    if (!hasPromptWithContent) {\n      ctx.report({\n        message: `Synthesis '${title}' is missing a '# Prompt' section. Add instructions for the LLM.`,\n        file: ctx.file,\n        location: entry.location,\n        sourceMap: ctx.sourceMap,\n        data: { title, linkId },\n      });\n    }\n  },\n};\n\n/**\n * Check that define-synthesis entries have a Prompt section\n */\nexport const synthesisMissingPromptRule: Rule = {\n  code: \"synthesis-missing-prompt\",\n  name: \"Synthesis Missing Prompt\",\n  description:\n    \"A define-synthesis entry should have a '# Prompt' section with instructions for the LLM\",\n  category,\n  defaultSeverity: \"warning\",\n  dependencies: { scope: \"entry\" },\n  visitor,\n};\n"],"mappings":";AAGA,MAAMA,WAAyB;AAE/B,MAAMC,UAAuB,EAC3B,oBAAoB,OAAO,KAAK;CAC9B,MAAM,QAAQ,MAAM,OAAO,MAAM;CACjC,MAAM,SAAS,MAAM,OAAO,OAAO;CACnC,MAAM,UAAU,MAAM;CAGtB,IAAI,uBAAuB;AAC3B,KAAI,SAAS;EACX,IAAI,oBAAoB;AACxB,OAAK,MAAM,SAAS,QAAQ,SAC1B,KAAI,MAAM,SAAS,qBAAqB,MAAM,KAAK,aAAa,CAAC,SAAS,SAAS,CACjF,qBAAoB;WACX,qBAAqB,MAAM,SAAS,gBAAgB;AAE7D,0BAAuB;AACvB;aACS,qBAAqB,MAAM,SAAS,kBAE7C;;AAKN,KAAI,CAAC,qBACH,KAAI,OAAO;EACT,SAAS,cAAc,MAAM;EAC7B,MAAM,IAAI;EACV,UAAU,MAAM;EAChB,WAAW,IAAI;EACf,MAAM;GAAE;GAAO;GAAQ;EACxB,CAAC;GAGP;;;;AAKD,MAAaC,6BAAmC;CAC9C,MAAM;CACN,MAAM;CACN,aACE;CACF;CACA,iBAAiB;CACjB,cAAc,EAAE,OAAO,SAAS;CAChC;CACD"}

package/dist/checker/rules/synthesis-missing-sources.js

@@ -0,0 +1,32 @@
+//#region src/checker/rules/synthesis-missing-sources.ts
+const category = "instance";
+const visitor = { visitSynthesisEntry(entry, ctx) {
+	const title = entry.header.title.value;
+	const linkId = entry.header.linkId.id;
+	if (!entry.metadata.find((m) => m.key.value === "sources")) ctx.report({
+		message: `Synthesis '${title}' is missing a 'sources:' field. Add a query like 'sources: lore where subject = ^self'.`,
+		file: ctx.file,
+		location: entry.location,
+		sourceMap: ctx.sourceMap,
+		data: {
+			title,
+			linkId
+		}
+	});
+} };
+/**
+* Check that define-synthesis entries have a sources field
+*/
+const synthesisMissingSourcesRule = {
+	code: "synthesis-missing-sources",
+	name: "Synthesis Missing Sources",
+	description: "A define-synthesis entry must have a 'sources:' field specifying which entries to query",
+	category,
+	defaultSeverity: "error",
+	dependencies: { scope: "entry" },
+	visitor
+};
+
+//#endregion
+export { synthesisMissingSourcesRule };
+//# sourceMappingURL=synthesis-missing-sources.js.map

package/dist/checker/rules/synthesis-missing-sources.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"synthesis-missing-sources.js","names":["category: RuleCategory","visitor: RuleVisitor","synthesisMissingSourcesRule: Rule"],"sources":["../../../src/checker/rules/synthesis-missing-sources.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\nimport type { RuleVisitor } from \"../visitor.js\";\n\nconst category: RuleCategory = \"instance\";\n\nconst visitor: RuleVisitor = {\n  visitSynthesisEntry(entry, ctx) {\n    const title = entry.header.title.value;\n    const linkId = entry.header.linkId.id;\n    const sourcesMetadata = entry.metadata.find((m) => m.key.value === \"sources\");\n\n    if (!sourcesMetadata) {\n      ctx.report({\n        message: `Synthesis '${title}' is missing a 'sources:' field. Add a query like 'sources: lore where subject = ^self'.`,\n        file: ctx.file,\n        location: entry.location,\n        sourceMap: ctx.sourceMap,\n        data: { title, linkId },\n      });\n    }\n  },\n};\n\n/**\n * Check that define-synthesis entries have a sources field\n */\nexport const synthesisMissingSourcesRule: Rule = {\n  code: \"synthesis-missing-sources\",\n  name: \"Synthesis Missing Sources\",\n  description:\n    \"A define-synthesis entry must have a 'sources:' field specifying which entries to query\",\n  category,\n  defaultSeverity: \"error\",\n  dependencies: { scope: \"entry\" },\n  visitor,\n};\n"],"mappings":";AAGA,MAAMA,WAAyB;AAE/B,MAAMC,UAAuB,EAC3B,oBAAoB,OAAO,KAAK;CAC9B,MAAM,QAAQ,MAAM,OAAO,MAAM;CACjC,MAAM,SAAS,MAAM,OAAO,OAAO;AAGnC,KAAI,CAFoB,MAAM,SAAS,MAAM,MAAM,EAAE,IAAI,UAAU,UAAU,CAG3E,KAAI,OAAO;EACT,SAAS,cAAc,MAAM;EAC7B,MAAM,IAAI;EACV,UAAU,MAAM;EAChB,WAAW,IAAI;EACf,MAAM;GAAE;GAAO;GAAQ;EACxB,CAAC;GAGP;;;;AAKD,MAAaC,8BAAoC;CAC/C,MAAM;CACN,MAAM;CACN,aACE;CACF;CACA,iBAAiB;CACjB,cAAc,EAAE,OAAO,SAAS;CAChC;CACD"}

package/dist/checker/rules/synthesis-unknown-query-entity.js

@@ -0,0 +1,39 @@
+//#region src/checker/rules/synthesis-unknown-query-entity.ts
+const category = "instance";
+const visitor = { visitSynthesisEntry(entry, ctx) {
+	const sourcesMeta = entry.metadata.find((m) => m.key.value === "sources");
+	if (!sourcesMeta) return;
+	const content = sourcesMeta.value.content;
+	const queries = [];
+	if (content.type === "query_value") queries.push(content.query);
+	else if (content.type === "value_array") {
+		for (const elem of content.elements) if (elem.type === "query") queries.push(elem);
+	}
+	const registry = ctx.workspace.schemaRegistry;
+	for (const query of queries) if (!registry.has(query.entity)) ctx.report({
+		message: `Unknown entity type '${query.entity}' in synthesis query. Define it using 'define-entity ${query.entity}'.`,
+		file: ctx.file,
+		location: query.location,
+		sourceMap: ctx.sourceMap,
+		data: { entity: query.entity }
+	});
+} };
+/**
+* Check that synthesis source queries reference defined entity types
+*/
+const synthesisUnknownQueryEntityRule = {
+	code: "synthesis-unknown-query-entity",
+	name: "Synthesis Unknown Query Entity",
+	description: "A synthesis source query must reference a defined entity type",
+	category,
+	defaultSeverity: "error",
+	dependencies: {
+		scope: "entry",
+		schemas: true
+	},
+	visitor
+};
+
+//#endregion
+export { synthesisUnknownQueryEntityRule };
+//# sourceMappingURL=synthesis-unknown-query-entity.js.map

package/dist/checker/rules/synthesis-unknown-query-entity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"synthesis-unknown-query-entity.js","names":["category: RuleCategory","visitor: RuleVisitor","queries: AstQuery[]","synthesisUnknownQueryEntityRule: Rule"],"sources":["../../../src/checker/rules/synthesis-unknown-query-entity.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\nimport type { RuleVisitor } from \"../visitor.js\";\nimport type { Query as AstQuery } from \"../../ast/ast-types.js\";\n\nconst category: RuleCategory = \"instance\";\n\nconst visitor: RuleVisitor = {\n  visitSynthesisEntry(entry, ctx) {\n    const sourcesMeta = entry.metadata.find((m) => m.key.value === \"sources\");\n    if (!sourcesMeta) {\n      // Missing sources is handled by synthesis-missing-sources rule\n      return;\n    }\n\n    const content = sourcesMeta.value.content;\n    const queries: AstQuery[] = [];\n\n    // Extract queries from sources (single query or array)\n    if (content.type === \"query_value\") {\n      queries.push(content.query);\n    } else if (content.type === \"value_array\") {\n      for (const elem of content.elements) {\n        if (elem.type === \"query\") {\n          queries.push(elem);\n        }\n      }\n    }\n\n    // Check each query's entity against the schema registry\n    const registry = ctx.workspace.schemaRegistry;\n    for (const query of queries) {\n      if (!registry.has(query.entity)) {\n        ctx.report({\n          message: `Unknown entity type '${query.entity}' in synthesis query. Define it using 'define-entity ${query.entity}'.`,\n          file: ctx.file,\n          location: query.location,\n          sourceMap: ctx.sourceMap,\n          data: { entity: query.entity },\n        });\n      }\n    }\n  },\n};\n\n/**\n * Check that synthesis source queries reference defined entity types\n */\nexport const synthesisUnknownQueryEntityRule: Rule = {\n  code: \"synthesis-unknown-query-entity\",\n  name: \"Synthesis Unknown Query Entity\",\n  description: \"A synthesis source query must reference a defined entity type\",\n  category,\n  defaultSeverity: \"error\",\n  dependencies: { scope: \"entry\", schemas: true },\n  visitor,\n};\n"],"mappings":";AAIA,MAAMA,WAAyB;AAE/B,MAAMC,UAAuB,EAC3B,oBAAoB,OAAO,KAAK;CAC9B,MAAM,cAAc,MAAM,SAAS,MAAM,MAAM,EAAE,IAAI,UAAU,UAAU;AACzE,KAAI,CAAC,YAEH;CAGF,MAAM,UAAU,YAAY,MAAM;CAClC,MAAMC,UAAsB,EAAE;AAG9B,KAAI,QAAQ,SAAS,cACnB,SAAQ,KAAK,QAAQ,MAAM;UAClB,QAAQ,SAAS,eAC1B;OAAK,MAAM,QAAQ,QAAQ,SACzB,KAAI,KAAK,SAAS,QAChB,SAAQ,KAAK,KAAK;;CAMxB,MAAM,WAAW,IAAI,UAAU;AAC/B,MAAK,MAAM,SAAS,QAClB,KAAI,CAAC,SAAS,IAAI,MAAM,OAAO,CAC7B,KAAI,OAAO;EACT,SAAS,wBAAwB,MAAM,OAAO,uDAAuD,MAAM,OAAO;EAClH,MAAM,IAAI;EACV,UAAU,MAAM;EAChB,WAAW,IAAI;EACf,MAAM,EAAE,QAAQ,MAAM,QAAQ;EAC/B,CAAC;GAIT;;;;AAKD,MAAaC,kCAAwC;CACnD,MAAM;CACN,MAAM;CACN,aAAa;CACb;CACA,iBAAiB;CACjB,cAAc;EAAE,OAAO;EAAS,SAAS;EAAM;CAC/C;CACD"}

package/dist/checker/rules/timestamp-out-of-order.js

@@ -0,0 +1,55 @@
+import { formatTimestamp } from "../../formatters.js";
+
+//#region src/checker/rules/timestamp-out-of-order.ts
+const category = "instance";
+/**
+* Compare two timestamps, returning negative if a < b, positive if a > b, 0 if equal
+*/
+function compareTimestamps(a, b) {
+	const aStr = formatTimestamp(a);
+	const bStr = formatTimestamp(b);
+	return aStr.localeCompare(bStr);
+}
+const visitor = { afterCheck(ctx) {
+	const { workspace } = ctx;
+	for (const model of workspace.allModels()) {
+		const entries = model.ast.entries;
+		if (entries.length < 2) continue;
+		let previousTimestamp = null;
+		for (const entry of entries) {
+			const timestamp = entry.type === "instance_entry" ? entry.header.timestamp : entry.type === "schema_entry" ? entry.header.timestamp : entry.type === "synthesis_entry" ? entry.header.timestamp : entry.type === "actualize_entry" ? entry.header.timestamp : null;
+			if (!timestamp) continue;
+			if (previousTimestamp !== null && compareTimestamps(timestamp, previousTimestamp) < 0) {
+				const currentStr = formatTimestamp(timestamp);
+				const previousStr = formatTimestamp(previousTimestamp);
+				ctx.report({
+					message: `Timestamp '${currentStr}' is earlier than previous entry '${previousStr}'. Entries should be in chronological order.`,
+					file: model.file,
+					location: entry.location,
+					sourceMap: model.sourceMap,
+					data: {
+						timestamp: currentStr,
+						previousTimestamp: previousStr
+					}
+				});
+			}
+			previousTimestamp = timestamp;
+		}
+	}
+} };
+/**
+* Check for timestamps that are out of chronological order within a document
+*/
+const timestampOutOfOrderRule = {
+	code: "timestamp-out-of-order",
+	name: "Timestamp Out of Order",
+	description: "Entry timestamp is earlier than the previous entry",
+	category,
+	defaultSeverity: "warning",
+	dependencies: { scope: "document" },
+	visitor
+};
+
+//#endregion
+export { timestampOutOfOrderRule };
+//# sourceMappingURL=timestamp-out-of-order.js.map

package/dist/checker/rules/timestamp-out-of-order.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp-out-of-order.js","names":["category: RuleCategory","visitor: RuleVisitor","previousTimestamp: Timestamp | null","timestampOutOfOrderRule: Rule"],"sources":["../../../src/checker/rules/timestamp-out-of-order.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\nimport type { RuleVisitor, VisitorContext } from \"../visitor.js\";\nimport type { Timestamp } from \"../../ast/ast-types.js\";\nimport { formatTimestamp } from \"../../formatters.js\";\n\nconst category: RuleCategory = \"instance\";\n\n/**\n * Compare two timestamps, returning negative if a < b, positive if a > b, 0 if equal\n */\nfunction compareTimestamps(a: Timestamp, b: Timestamp): number {\n  const aStr = formatTimestamp(a);\n  const bStr = formatTimestamp(b);\n  return aStr.localeCompare(bStr);\n}\n\nconst visitor: RuleVisitor = {\n  afterCheck(ctx: VisitorContext) {\n    const { workspace } = ctx;\n\n    for (const model of workspace.allModels()) {\n      const entries = model.ast.entries;\n\n      if (entries.length < 2) {\n        continue;\n      }\n\n      let previousTimestamp: Timestamp | null = null;\n\n      for (const entry of entries) {\n        // Get timestamp from entry header\n        const timestamp =\n          entry.type === \"instance_entry\"\n            ? entry.header.timestamp\n            : entry.type === \"schema_entry\"\n              ? entry.header.timestamp\n              : entry.type === \"synthesis_entry\"\n                ? entry.header.timestamp\n                : entry.type === \"actualize_entry\"\n                  ? entry.header.timestamp\n                  : null;\n\n        if (!timestamp) {\n          continue;\n        }\n\n        if (previousTimestamp !== null && compareTimestamps(timestamp, previousTimestamp) < 0) {\n          const currentStr = formatTimestamp(timestamp);\n          const previousStr = formatTimestamp(previousTimestamp);\n\n          ctx.report({\n            message: `Timestamp '${currentStr}' is earlier than previous entry '${previousStr}'. Entries should be in chronological order.`,\n            file: model.file,\n            location: entry.location,\n            sourceMap: model.sourceMap,\n            data: {\n              timestamp: currentStr,\n              previousTimestamp: previousStr,\n            },\n          });\n        }\n\n        previousTimestamp = timestamp;\n      }\n    }\n  },\n};\n\n/**\n * Check for timestamps that are out of chronological order within a document\n */\nexport const timestampOutOfOrderRule: Rule = {\n  code: \"timestamp-out-of-order\",\n  name: \"Timestamp Out of Order\",\n  description: \"Entry timestamp is earlier than the previous entry\",\n  category,\n  defaultSeverity: \"warning\",\n  dependencies: { scope: \"document\" },\n  visitor,\n};\n"],"mappings":";;;AAKA,MAAMA,WAAyB;;;;AAK/B,SAAS,kBAAkB,GAAc,GAAsB;CAC7D,MAAM,OAAO,gBAAgB,EAAE;CAC/B,MAAM,OAAO,gBAAgB,EAAE;AAC/B,QAAO,KAAK,cAAc,KAAK;;AAGjC,MAAMC,UAAuB,EAC3B,WAAW,KAAqB;CAC9B,MAAM,EAAE,cAAc;AAEtB,MAAK,MAAM,SAAS,UAAU,WAAW,EAAE;EACzC,MAAM,UAAU,MAAM,IAAI;AAE1B,MAAI,QAAQ,SAAS,EACnB;EAGF,IAAIC,oBAAsC;AAE1C,OAAK,MAAM,SAAS,SAAS;GAE3B,MAAM,YACJ,MAAM,SAAS,mBACX,MAAM,OAAO,YACb,MAAM,SAAS,iBACb,MAAM,OAAO,YACb,MAAM,SAAS,oBACb,MAAM,OAAO,YACb,MAAM,SAAS,oBACb,MAAM,OAAO,YACb;AAEZ,OAAI,CAAC,UACH;AAGF,OAAI,sBAAsB,QAAQ,kBAAkB,WAAW,kBAAkB,GAAG,GAAG;IACrF,MAAM,aAAa,gBAAgB,UAAU;IAC7C,MAAM,cAAc,gBAAgB,kBAAkB;AAEtD,QAAI,OAAO;KACT,SAAS,cAAc,WAAW,oCAAoC,YAAY;KAClF,MAAM,MAAM;KACZ,UAAU,MAAM;KAChB,WAAW,MAAM;KACjB,MAAM;MACJ,WAAW;MACX,mBAAmB;MACpB;KACF,CAAC;;AAGJ,uBAAoB;;;GAI3B;;;;AAKD,MAAaC,0BAAgC;CAC3C,MAAM;CACN,MAAM;CACN,aAAa;CACb;CACA,iBAAiB;CACjB,cAAc,EAAE,OAAO,YAAY;CACnC;CACD"}

package/dist/checker/rules/unknown-entity.js

@@ -0,0 +1,32 @@
+//#region src/checker/rules/unknown-entity.ts
+const category = "instance";
+const visitor = { visitInstanceEntry(entry, ctx) {
+	const registry = ctx.workspace.schemaRegistry;
+	const entity = entry.header.entity;
+	if (!registry.has(entity)) ctx.report({
+		message: `Unknown entity type '${entity}'. Define it using 'define-entity ${entity}'.`,
+		file: ctx.file,
+		location: entry.location,
+		sourceMap: ctx.sourceMap,
+		data: { entity }
+	});
+} };
+/**
+* Check for instance entries using undefined entity types
+*/
+const unknownEntityRule = {
+	code: "unknown-entity",
+	name: "Unknown Entity",
+	description: "Instance entry uses an undefined entity type",
+	category,
+	defaultSeverity: "error",
+	dependencies: {
+		scope: "entry",
+		schemas: true
+	},
+	visitor
+};
+
+//#endregion
+export { unknownEntityRule };
+//# sourceMappingURL=unknown-entity.js.map

package/dist/checker/rules/unknown-entity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unknown-entity.js","names":["category: RuleCategory","visitor: RuleVisitor","unknownEntityRule: Rule"],"sources":["../../../src/checker/rules/unknown-entity.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\nimport type { RuleVisitor } from \"../visitor.js\";\n\nconst category: RuleCategory = \"instance\";\n\nconst visitor: RuleVisitor = {\n  visitInstanceEntry(entry, ctx) {\n    const registry = ctx.workspace.schemaRegistry;\n    const entity = entry.header.entity;\n\n    if (!registry.has(entity)) {\n      ctx.report({\n        message: `Unknown entity type '${entity}'. Define it using 'define-entity ${entity}'.`,\n        file: ctx.file,\n        location: entry.location,\n        sourceMap: ctx.sourceMap,\n        data: { entity },\n      });\n    }\n  },\n};\n\n/**\n * Check for instance entries using undefined entity types\n */\nexport const unknownEntityRule: Rule = {\n  code: \"unknown-entity\",\n  name: \"Unknown Entity\",\n  description: \"Instance entry uses an undefined entity type\",\n  category,\n  defaultSeverity: \"error\",\n  dependencies: { scope: \"entry\", schemas: true },\n  visitor,\n};\n"],"mappings":";AAGA,MAAMA,WAAyB;AAE/B,MAAMC,UAAuB,EAC3B,mBAAmB,OAAO,KAAK;CAC7B,MAAM,WAAW,IAAI,UAAU;CAC/B,MAAM,SAAS,MAAM,OAAO;AAE5B,KAAI,CAAC,SAAS,IAAI,OAAO,CACvB,KAAI,OAAO;EACT,SAAS,wBAAwB,OAAO,oCAAoC,OAAO;EACnF,MAAM,IAAI;EACV,UAAU,MAAM;EAChB,WAAW,IAAI;EACf,MAAM,EAAE,QAAQ;EACjB,CAAC;GAGP;;;;AAKD,MAAaC,oBAA0B;CACrC,MAAM;CACN,MAAM;CACN,aAAa;CACb;CACA,iBAAiB;CACjB,cAAc;EAAE,OAAO;EAAS,SAAS;EAAM;CAC/C;CACD"}

package/dist/checker/rules/unknown-field.js

@@ -0,0 +1,40 @@
+//#region src/checker/rules/unknown-field.ts
+const category = "instance";
+const visitor = { visitInstanceEntry(entry, ctx) {
+	const registry = ctx.workspace.schemaRegistry;
+	const entity = entry.header.entity;
+	const schema = registry.get(entity);
+	if (!schema) return;
+	for (const meta of entry.metadata) {
+		const fieldName = meta.key.value;
+		if (!schema.fields.has(fieldName)) ctx.report({
+			message: `Unknown field '${fieldName}' for entity '${entity}'.`,
+			file: ctx.file,
+			location: meta.key.location,
+			sourceMap: ctx.sourceMap,
+			data: {
+				field: fieldName,
+				entity
+			}
+		});
+	}
+} };
+/**
+* Check for metadata fields not defined in the entity schema
+*/
+const unknownFieldRule = {
+	code: "unknown-field",
+	name: "Unknown Field",
+	description: "Metadata field not defined in entity schema",
+	category,
+	defaultSeverity: "warning",
+	dependencies: {
+		scope: "entry",
+		schemas: true
+	},
+	visitor
+};
+
+//#endregion
+export { unknownFieldRule };
+//# sourceMappingURL=unknown-field.js.map

package/dist/checker/rules/unknown-field.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unknown-field.js","names":["category: RuleCategory","visitor: RuleVisitor","unknownFieldRule: Rule"],"sources":["../../../src/checker/rules/unknown-field.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\nimport type { RuleVisitor } from \"../visitor.js\";\n\nconst category: RuleCategory = \"instance\";\n\nconst visitor: RuleVisitor = {\n  visitInstanceEntry(entry, ctx) {\n    const registry = ctx.workspace.schemaRegistry;\n    const entity = entry.header.entity;\n    const schema = registry.get(entity);\n\n    if (!schema) {\n      return; // Will be caught by unknown-entity rule\n    }\n\n    for (const meta of entry.metadata) {\n      const fieldName = meta.key.value;\n      if (!schema.fields.has(fieldName)) {\n        ctx.report({\n          message: `Unknown field '${fieldName}' for entity '${entity}'.`,\n          file: ctx.file,\n          // Use key.location to point to the field name, not the leading indent\n          location: meta.key.location,\n          sourceMap: ctx.sourceMap,\n          data: { field: fieldName, entity },\n        });\n      }\n    }\n  },\n};\n\n/**\n * Check for metadata fields not defined in the entity schema\n */\nexport const unknownFieldRule: Rule = {\n  code: \"unknown-field\",\n  name: \"Unknown Field\",\n  description: \"Metadata field not defined in entity schema\",\n  category,\n  defaultSeverity: \"warning\",\n  dependencies: { scope: \"entry\", schemas: true },\n  visitor,\n};\n"],"mappings":";AAGA,MAAMA,WAAyB;AAE/B,MAAMC,UAAuB,EAC3B,mBAAmB,OAAO,KAAK;CAC7B,MAAM,WAAW,IAAI,UAAU;CAC/B,MAAM,SAAS,MAAM,OAAO;CAC5B,MAAM,SAAS,SAAS,IAAI,OAAO;AAEnC,KAAI,CAAC,OACH;AAGF,MAAK,MAAM,QAAQ,MAAM,UAAU;EACjC,MAAM,YAAY,KAAK,IAAI;AAC3B,MAAI,CAAC,OAAO,OAAO,IAAI,UAAU,CAC/B,KAAI,OAAO;GACT,SAAS,kBAAkB,UAAU,gBAAgB,OAAO;GAC5D,MAAM,IAAI;GAEV,UAAU,KAAK,IAAI;GACnB,WAAW,IAAI;GACf,MAAM;IAAE,OAAO;IAAW;IAAQ;GACnC,CAAC;;GAIT;;;;AAKD,MAAaC,mBAAyB;CACpC,MAAM;CACN,MAAM;CACN,aAAa;CACb;CACA,iBAAiB;CACjB,cAAc;EAAE,OAAO;EAAS,SAAS;EAAM;CAC/C;CACD"}

package/dist/checker/rules/unknown-section.js

@@ -0,0 +1,47 @@
+//#region src/checker/rules/unknown-section.ts
+const category = "instance";
+/**
+* Extract section names from entry content (markdown headers)
+*/
+function getSectionNames(entry) {
+	if (!entry.content) return [];
+	return entry.content.children.filter((c) => c.type === "markdown_header").map((h) => {
+		const match = h.text.match(/^#+\s*(.+)$/);
+		return match ? match[1].trim() : h.text;
+	});
+}
+const visitor = { visitInstanceEntry(entry, ctx) {
+	const registry = ctx.workspace.schemaRegistry;
+	const entity = entry.header.entity;
+	const schema = registry.get(entity);
+	if (!schema) return;
+	for (const sectionName of getSectionNames(entry)) if (!schema.sections.has(sectionName)) ctx.report({
+		message: `Unknown section '${sectionName}' for entity '${entity}'.`,
+		file: ctx.file,
+		location: entry.location,
+		sourceMap: ctx.sourceMap,
+		data: {
+			section: sectionName,
+			entity
+		}
+	});
+} };
+/**
+* Check for sections in content not defined in the entity schema
+*/
+const unknownSectionRule = {
+	code: "unknown-section",
+	name: "Unknown Section",
+	description: "Section not defined in entity schema",
+	category,
+	defaultSeverity: "warning",
+	dependencies: {
+		scope: "entry",
+		schemas: true
+	},
+	visitor
+};
+
+//#endregion
+export { unknownSectionRule };
+//# sourceMappingURL=unknown-section.js.map

package/dist/checker/rules/unknown-section.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unknown-section.js","names":["category: RuleCategory","visitor: RuleVisitor","unknownSectionRule: Rule"],"sources":["../../../src/checker/rules/unknown-section.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\nimport type { RuleVisitor } from \"../visitor.js\";\nimport type { InstanceEntry } from \"../../ast/ast-types.js\";\n\nconst category: RuleCategory = \"instance\";\n\n/**\n * Extract section names from entry content (markdown headers)\n */\nfunction getSectionNames(entry: InstanceEntry): string[] {\n  if (!entry.content) {\n    return [];\n  }\n  return entry.content.children\n    .filter((c) => c.type === \"markdown_header\")\n    .map((h) => {\n      // Extract section name from \"# SectionName\" format\n      const match = h.text.match(/^#+\\s*(.+)$/);\n      return match ? match[1].trim() : h.text;\n    });\n}\n\nconst visitor: RuleVisitor = {\n  visitInstanceEntry(entry, ctx) {\n    const registry = ctx.workspace.schemaRegistry;\n    const entity = entry.header.entity;\n    const schema = registry.get(entity);\n\n    if (!schema) {\n      return; // Will be caught by unknown-entity rule\n    }\n\n    for (const sectionName of getSectionNames(entry)) {\n      if (!schema.sections.has(sectionName)) {\n        ctx.report({\n          message: `Unknown section '${sectionName}' for entity '${entity}'.`,\n          file: ctx.file,\n          location: entry.location, // Ideally we'd have the section's location\n          sourceMap: ctx.sourceMap,\n          data: { section: sectionName, entity },\n        });\n      }\n    }\n  },\n};\n\n/**\n * Check for sections in content not defined in the entity schema\n */\nexport const unknownSectionRule: Rule = {\n  code: \"unknown-section\",\n  name: \"Unknown Section\",\n  description: \"Section not defined in entity schema\",\n  category,\n  defaultSeverity: \"warning\",\n  dependencies: { scope: \"entry\", schemas: true },\n  visitor,\n};\n"],"mappings":";AAIA,MAAMA,WAAyB;;;;AAK/B,SAAS,gBAAgB,OAAgC;AACvD,KAAI,CAAC,MAAM,QACT,QAAO,EAAE;AAEX,QAAO,MAAM,QAAQ,SAClB,QAAQ,MAAM,EAAE,SAAS,kBAAkB,CAC3C,KAAK,MAAM;EAEV,MAAM,QAAQ,EAAE,KAAK,MAAM,cAAc;AACzC,SAAO,QAAQ,MAAM,GAAG,MAAM,GAAG,EAAE;GACnC;;AAGN,MAAMC,UAAuB,EAC3B,mBAAmB,OAAO,KAAK;CAC7B,MAAM,WAAW,IAAI,UAAU;CAC/B,MAAM,SAAS,MAAM,OAAO;CAC5B,MAAM,SAAS,SAAS,IAAI,OAAO;AAEnC,KAAI,CAAC,OACH;AAGF,MAAK,MAAM,eAAe,gBAAgB,MAAM,CAC9C,KAAI,CAAC,OAAO,SAAS,IAAI,YAAY,CACnC,KAAI,OAAO;EACT,SAAS,oBAAoB,YAAY,gBAAgB,OAAO;EAChE,MAAM,IAAI;EACV,UAAU,MAAM;EAChB,WAAW,IAAI;EACf,MAAM;GAAE,SAAS;GAAa;GAAQ;EACvC,CAAC;GAIT;;;;AAKD,MAAaC,qBAA2B;CACtC,MAAM;CACN,MAAM;CACN,aAAa;CACb;CACA,iBAAiB;CACjB,cAAc;EAAE,OAAO;EAAS,SAAS;EAAM;CAC/C;CACD"}

package/dist/checker/rules/unresolved-link.js

@@ -0,0 +1,34 @@
+//#region src/checker/rules/unresolved-link.ts
+const category = "link";
+const visitor = { afterCheck(ctx) {
+	const linkIndex = ctx.workspace.linkIndex;
+	for (const [linkId, refs] of linkIndex.references) if (!linkIndex.definitions.get(linkId)) for (const ref of refs) {
+		const model = ctx.workspace.getModel(ref.file);
+		ctx.report({
+			message: `Unresolved link '^${linkId}'. No entry defines this link ID.`,
+			file: ref.file,
+			location: ref.location,
+			sourceMap: model?.sourceMap,
+			data: { linkId }
+		});
+	}
+} };
+/**
+* Check for link references that don't resolve to any definition
+*/
+const unresolvedLinkRule = {
+	code: "unresolved-link",
+	name: "Unresolved Link",
+	description: "Link reference (^id) has no definition",
+	category,
+	defaultSeverity: "warning",
+	dependencies: {
+		scope: "workspace",
+		links: true
+	},
+	visitor
+};
+
+//#endregion
+export { unresolvedLinkRule };
+//# sourceMappingURL=unresolved-link.js.map

package/dist/checker/rules/unresolved-link.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unresolved-link.js","names":["category: RuleCategory","visitor: RuleVisitor","unresolvedLinkRule: Rule"],"sources":["../../../src/checker/rules/unresolved-link.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\nimport type { RuleVisitor, VisitorContext } from \"../visitor.js\";\n\nconst category: RuleCategory = \"link\";\n\nconst visitor: RuleVisitor = {\n  afterCheck(ctx: VisitorContext) {\n    const linkIndex = ctx.workspace.linkIndex;\n\n    // Check all references to see if they have definitions\n    for (const [linkId, refs] of linkIndex.references) {\n      const definition = linkIndex.definitions.get(linkId);\n\n      if (!definition) {\n        // No definition found - report for each reference\n        for (const ref of refs) {\n          // Get source map from the model\n          const model = ctx.workspace.getModel(ref.file);\n\n          ctx.report({\n            message: `Unresolved link '^${linkId}'. No entry defines this link ID.`,\n            file: ref.file,\n            location: ref.location,\n            sourceMap: model?.sourceMap,\n            data: { linkId },\n          });\n        }\n      }\n    }\n  },\n};\n\n/**\n * Check for link references that don't resolve to any definition\n */\nexport const unresolvedLinkRule: Rule = {\n  code: \"unresolved-link\",\n  name: \"Unresolved Link\",\n  description: \"Link reference (^id) has no definition\",\n  category,\n  defaultSeverity: \"warning\",\n  dependencies: { scope: \"workspace\", links: true },\n  visitor,\n};\n"],"mappings":";AAGA,MAAMA,WAAyB;AAE/B,MAAMC,UAAuB,EAC3B,WAAW,KAAqB;CAC9B,MAAM,YAAY,IAAI,UAAU;AAGhC,MAAK,MAAM,CAAC,QAAQ,SAAS,UAAU,WAGrC,KAAI,CAFe,UAAU,YAAY,IAAI,OAAO,CAIlD,MAAK,MAAM,OAAO,MAAM;EAEtB,MAAM,QAAQ,IAAI,UAAU,SAAS,IAAI,KAAK;AAE9C,MAAI,OAAO;GACT,SAAS,qBAAqB,OAAO;GACrC,MAAM,IAAI;GACV,UAAU,IAAI;GACd,WAAW,OAAO;GAClB,MAAM,EAAE,QAAQ;GACjB,CAAC;;GAKX;;;;AAKD,MAAaC,qBAA2B;CACtC,MAAM;CACN,MAAM;CACN,aAAa;CACb;CACA,iBAAiB;CACjB,cAAc;EAAE,OAAO;EAAa,OAAO;EAAM;CACjD;CACD"}

package/dist/checker/rules/update-without-create.js

@@ -0,0 +1,65 @@
+//#region src/checker/rules/update-without-create.ts
+const category = "instance";
+/**
+* Get metadata link value for a given key
+*/
+function getMetadataLink(entry, key) {
+	const meta = entry.metadata.find((m) => m.key.value === key);
+	if (!meta) return null;
+	const content = meta.value.content;
+	if (content.type === "link_value") return {
+		id: content.link.id,
+		location: content.link.location
+	};
+	return null;
+}
+const visitor = { visitInstanceEntry(entry, ctx) {
+	if (entry.header.directive !== "update") return;
+	const supersedes = getMetadataLink(entry, "supersedes");
+	if (!supersedes) return;
+	const definition = ctx.workspace.getLinkDefinition(supersedes.id);
+	if (!definition) return;
+	const supersededEntry = definition.entry;
+	if (supersededEntry.type === "instance_entry") {
+		if (supersededEntry.header.directive !== "create") ctx.report({
+			message: `'update' entry supersedes another '${supersededEntry.header.directive}' entry. Consider pointing to the original 'create' entry instead.`,
+			file: ctx.file,
+			location: supersedes.location,
+			sourceMap: ctx.sourceMap,
+			data: {
+				linkId: supersedes.id,
+				supersededDirective: supersededEntry.header.directive
+			}
+		});
+		else if (supersededEntry.header.entity !== entry.header.entity) ctx.report({
+			message: `'update ${entry.header.entity}' supersedes a '${supersededEntry.header.entity}' entry. Entity types should match.`,
+			file: ctx.file,
+			location: supersedes.location,
+			sourceMap: ctx.sourceMap,
+			data: {
+				linkId: supersedes.id,
+				expectedEntity: entry.header.entity,
+				actualEntity: supersededEntry.header.entity
+			}
+		});
+	}
+} };
+/**
+* Check for 'update' entries that reference (via supersedes) a non-existent create entry
+*/
+const updateWithoutCreateRule = {
+	code: "update-without-create",
+	name: "Update Without Create",
+	description: "update entry supersedes wrong directive/entity type",
+	category,
+	defaultSeverity: "warning",
+	dependencies: {
+		scope: "entry",
+		links: true
+	},
+	visitor
+};
+
+//#endregion
+export { updateWithoutCreateRule };
+//# sourceMappingURL=update-without-create.js.map

package/dist/checker/rules/update-without-create.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-without-create.js","names":["category: RuleCategory","visitor: RuleVisitor","updateWithoutCreateRule: Rule"],"sources":["../../../src/checker/rules/update-without-create.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\nimport type { RuleVisitor } from \"../visitor.js\";\nimport type { InstanceEntry } from \"../../ast/ast-types.js\";\n\nconst category: RuleCategory = \"instance\";\n\n/**\n * Get metadata link value for a given key\n */\nfunction getMetadataLink(\n  entry: InstanceEntry,\n  key: string,\n): { id: string; location: import(\"../../ast/ast-types.js\").Location } | null {\n  const meta = entry.metadata.find((m) => m.key.value === key);\n  if (!meta) {\n    return null;\n  }\n\n  const content = meta.value.content;\n  if (content.type === \"link_value\") {\n    return { id: content.link.id, location: content.link.location };\n  }\n  return null;\n}\n\nconst visitor: RuleVisitor = {\n  visitInstanceEntry(entry, ctx) {\n    if (entry.header.directive !== \"update\") {\n      return;\n    }\n\n    // Check if there's a supersedes field\n    const supersedes = getMetadataLink(entry, \"supersedes\");\n    if (!supersedes) {\n      return;\n    }\n\n    // Check if the superseded entry exists\n    const definition = ctx.workspace.getLinkDefinition(supersedes.id);\n    if (!definition) {\n      // This will be caught by unresolved-link rule\n      return;\n    }\n\n    // Check if the superseded entry is a create of the same entity type\n    const supersededEntry = definition.entry;\n    if (supersededEntry.type === \"instance_entry\") {\n      if (supersededEntry.header.directive !== \"create\") {\n        ctx.report({\n          message: `'update' entry supersedes another '${supersededEntry.header.directive}' entry. Consider pointing to the original 'create' entry instead.`,\n          file: ctx.file,\n          location: supersedes.location,\n          sourceMap: ctx.sourceMap,\n          data: {\n            linkId: supersedes.id,\n            supersededDirective: supersededEntry.header.directive,\n          },\n        });\n      } else if (supersededEntry.header.entity !== entry.header.entity) {\n        ctx.report({\n          message: `'update ${entry.header.entity}' supersedes a '${supersededEntry.header.entity}' entry. Entity types should match.`,\n          file: ctx.file,\n          location: supersedes.location,\n          sourceMap: ctx.sourceMap,\n          data: {\n            linkId: supersedes.id,\n            expectedEntity: entry.header.entity,\n            actualEntity: supersededEntry.header.entity,\n          },\n        });\n      }\n    }\n  },\n};\n\n/**\n * Check for 'update' entries that reference (via supersedes) a non-existent create entry\n */\nexport const updateWithoutCreateRule: Rule = {\n  code: \"update-without-create\",\n  name: \"Update Without Create\",\n  description: \"update entry supersedes wrong directive/entity type\",\n  category,\n  defaultSeverity: \"warning\",\n  dependencies: { scope: \"entry\", links: true },\n  visitor,\n};\n"],"mappings":";AAIA,MAAMA,WAAyB;;;;AAK/B,SAAS,gBACP,OACA,KAC4E;CAC5E,MAAM,OAAO,MAAM,SAAS,MAAM,MAAM,EAAE,IAAI,UAAU,IAAI;AAC5D,KAAI,CAAC,KACH,QAAO;CAGT,MAAM,UAAU,KAAK,MAAM;AAC3B,KAAI,QAAQ,SAAS,aACnB,QAAO;EAAE,IAAI,QAAQ,KAAK;EAAI,UAAU,QAAQ,KAAK;EAAU;AAEjE,QAAO;;AAGT,MAAMC,UAAuB,EAC3B,mBAAmB,OAAO,KAAK;AAC7B,KAAI,MAAM,OAAO,cAAc,SAC7B;CAIF,MAAM,aAAa,gBAAgB,OAAO,aAAa;AACvD,KAAI,CAAC,WACH;CAIF,MAAM,aAAa,IAAI,UAAU,kBAAkB,WAAW,GAAG;AACjE,KAAI,CAAC,WAEH;CAIF,MAAM,kBAAkB,WAAW;AACnC,KAAI,gBAAgB,SAAS,kBAC3B;MAAI,gBAAgB,OAAO,cAAc,SACvC,KAAI,OAAO;GACT,SAAS,sCAAsC,gBAAgB,OAAO,UAAU;GAChF,MAAM,IAAI;GACV,UAAU,WAAW;GACrB,WAAW,IAAI;GACf,MAAM;IACJ,QAAQ,WAAW;IACnB,qBAAqB,gBAAgB,OAAO;IAC7C;GACF,CAAC;WACO,gBAAgB,OAAO,WAAW,MAAM,OAAO,OACxD,KAAI,OAAO;GACT,SAAS,WAAW,MAAM,OAAO,OAAO,kBAAkB,gBAAgB,OAAO,OAAO;GACxF,MAAM,IAAI;GACV,UAAU,WAAW;GACrB,WAAW,IAAI;GACf,MAAM;IACJ,QAAQ,WAAW;IACnB,gBAAgB,MAAM,OAAO;IAC7B,cAAc,gBAAgB,OAAO;IACtC;GACF,CAAC;;GAIT;;;;AAKD,MAAaC,0BAAgC;CAC3C,MAAM;CACN,MAAM;CACN,aAAa;CACb;CACA,iBAAiB;CACjB,cAAc;EAAE,OAAO;EAAS,OAAO;EAAM;CAC7C;CACD"}