@rejot-dev/thalo 0.0.0

package/dist/checker/rules/alter-before-define.js

@@ -0,0 +1,53 @@
+import { formatTimestamp } from "../../formatters.js";
+
+//#region src/checker/rules/alter-before-define.ts
+const category = "schema";
+const visitor = { afterCheck(ctx) {
+	const { index } = ctx;
+	for (const [entityName, alterEntries] of index.alterEntitiesByName) {
+		const defineEntries = index.defineEntitiesByName.get(entityName);
+		if (!defineEntries || defineEntries.length === 0) continue;
+		let earliestDefine = null;
+		let earliestDefineTs = "";
+		for (const entry of defineEntries) {
+			const ts = formatTimestamp(entry.entry.header.timestamp);
+			if (!earliestDefine || ts < earliestDefineTs) {
+				earliestDefine = entry;
+				earliestDefineTs = ts;
+			}
+		}
+		for (const { entry, file, sourceMap } of alterEntries) {
+			const alterTs = formatTimestamp(entry.header.timestamp);
+			if (alterTs < earliestDefineTs) ctx.report({
+				message: `alter-entity for '${entityName}' has timestamp ${alterTs} which is before the define-entity at ${earliestDefineTs}.`,
+				file,
+				location: entry.location,
+				sourceMap,
+				data: {
+					entityName,
+					alterTimestamp: alterTs,
+					defineTimestamp: earliestDefineTs
+				}
+			});
+		}
+	}
+} };
+/**
+* Check for alter-entity entries with timestamps earlier than the define-entity
+*/
+const alterBeforeDefineRule = {
+	code: "alter-before-define",
+	name: "Alter Before Define",
+	description: "alter-entity timestamp before define-entity",
+	category,
+	defaultSeverity: "error",
+	dependencies: {
+		scope: "workspace",
+		schemas: true
+	},
+	visitor
+};
+
+//#endregion
+export { alterBeforeDefineRule };
+//# sourceMappingURL=alter-before-define.js.map

package/dist/checker/rules/alter-before-define.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alter-before-define.js","names":["category: RuleCategory","visitor: RuleVisitor","earliestDefine: IndexedEntry<SchemaEntry> | null","alterBeforeDefineRule: Rule"],"sources":["../../../src/checker/rules/alter-before-define.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\nimport type { RuleVisitor, VisitorContext } from \"../visitor.js\";\nimport type { SchemaEntry } from \"../../ast/ast-types.js\";\nimport type { IndexedEntry } from \"../workspace-index.js\";\nimport { formatTimestamp } from \"../../formatters.js\";\n\nconst category: RuleCategory = \"schema\";\n\nconst visitor: RuleVisitor = {\n  afterCheck(ctx: VisitorContext) {\n    const { index } = ctx;\n\n    // For each entity with alter entries, check against define entries\n    for (const [entityName, alterEntries] of index.alterEntitiesByName) {\n      const defineEntries = index.defineEntitiesByName.get(entityName);\n      if (!defineEntries || defineEntries.length === 0) {\n        continue; // No define - handled by alter-undefined-entity rule\n      }\n\n      // Find the earliest define timestamp\n      let earliestDefine: IndexedEntry<SchemaEntry> | null = null;\n      let earliestDefineTs = \"\";\n\n      for (const entry of defineEntries) {\n        const ts = formatTimestamp(entry.entry.header.timestamp);\n        if (!earliestDefine || ts < earliestDefineTs) {\n          earliestDefine = entry;\n          earliestDefineTs = ts;\n        }\n      }\n\n      // Check each alter entry\n      for (const { entry, file, sourceMap } of alterEntries) {\n        const alterTs = formatTimestamp(entry.header.timestamp);\n\n        if (alterTs < earliestDefineTs) {\n          ctx.report({\n            message: `alter-entity for '${entityName}' has timestamp ${alterTs} which is before the define-entity at ${earliestDefineTs}.`,\n            file,\n            location: entry.location,\n            sourceMap,\n            data: {\n              entityName,\n              alterTimestamp: alterTs,\n              defineTimestamp: earliestDefineTs,\n            },\n          });\n        }\n      }\n    }\n  },\n};\n\n/**\n * Check for alter-entity entries with timestamps earlier than the define-entity\n */\nexport const alterBeforeDefineRule: Rule = {\n  code: \"alter-before-define\",\n  name: \"Alter Before Define\",\n  description: \"alter-entity timestamp before define-entity\",\n  category,\n  defaultSeverity: \"error\",\n  dependencies: { scope: \"workspace\", schemas: true },\n  visitor,\n};\n"],"mappings":";;;AAMA,MAAMA,WAAyB;AAE/B,MAAMC,UAAuB,EAC3B,WAAW,KAAqB;CAC9B,MAAM,EAAE,UAAU;AAGlB,MAAK,MAAM,CAAC,YAAY,iBAAiB,MAAM,qBAAqB;EAClE,MAAM,gBAAgB,MAAM,qBAAqB,IAAI,WAAW;AAChE,MAAI,CAAC,iBAAiB,cAAc,WAAW,EAC7C;EAIF,IAAIC,iBAAmD;EACvD,IAAI,mBAAmB;AAEvB,OAAK,MAAM,SAAS,eAAe;GACjC,MAAM,KAAK,gBAAgB,MAAM,MAAM,OAAO,UAAU;AACxD,OAAI,CAAC,kBAAkB,KAAK,kBAAkB;AAC5C,qBAAiB;AACjB,uBAAmB;;;AAKvB,OAAK,MAAM,EAAE,OAAO,MAAM,eAAe,cAAc;GACrD,MAAM,UAAU,gBAAgB,MAAM,OAAO,UAAU;AAEvD,OAAI,UAAU,iBACZ,KAAI,OAAO;IACT,SAAS,qBAAqB,WAAW,kBAAkB,QAAQ,wCAAwC,iBAAiB;IAC5H;IACA,UAAU,MAAM;IAChB;IACA,MAAM;KACJ;KACA,gBAAgB;KAChB,iBAAiB;KAClB;IACF,CAAC;;;GAKX;;;;AAKD,MAAaC,wBAA8B;CACzC,MAAM;CACN,MAAM;CACN,aAAa;CACb;CACA,iBAAiB;CACjB,cAAc;EAAE,OAAO;EAAa,SAAS;EAAM;CACnD;CACD"}

package/dist/checker/rules/alter-undefined-entity.js

@@ -0,0 +1,32 @@
+//#region src/checker/rules/alter-undefined-entity.ts
+const category = "schema";
+const visitor = { afterCheck(ctx) {
+	const { index } = ctx;
+	const definedEntities = new Set(index.defineEntitiesByName.keys());
+	for (const [entityName, alters] of index.alterEntitiesByName) if (!definedEntities.has(entityName)) for (const { entry, file, sourceMap } of alters) ctx.report({
+		message: `Cannot alter undefined entity '${entityName}'. Define it first using 'define-entity ${entityName}'.`,
+		file,
+		location: entry.location,
+		sourceMap,
+		data: { entityName }
+	});
+} };
+/**
+* Check for alter-entity entries targeting entities that were never defined
+*/
+const alterUndefinedEntityRule = {
+	code: "alter-undefined-entity",
+	name: "Alter Undefined Entity",
+	description: "alter-entity targets an undefined entity",
+	category,
+	defaultSeverity: "error",
+	dependencies: {
+		scope: "workspace",
+		schemas: true
+	},
+	visitor
+};
+
+//#endregion
+export { alterUndefinedEntityRule };
+//# sourceMappingURL=alter-undefined-entity.js.map

package/dist/checker/rules/alter-undefined-entity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alter-undefined-entity.js","names":["category: RuleCategory","visitor: RuleVisitor","alterUndefinedEntityRule: Rule"],"sources":["../../../src/checker/rules/alter-undefined-entity.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\nimport type { RuleVisitor, VisitorContext } from \"../visitor.js\";\n\nconst category: RuleCategory = \"schema\";\n\nconst visitor: RuleVisitor = {\n  afterCheck(ctx: VisitorContext) {\n    const { index } = ctx;\n\n    // Get all defined entity names\n    const definedEntities = new Set(index.defineEntitiesByName.keys());\n\n    // Check alter-entity entries\n    for (const [entityName, alters] of index.alterEntitiesByName) {\n      if (!definedEntities.has(entityName)) {\n        for (const { entry, file, sourceMap } of alters) {\n          ctx.report({\n            message: `Cannot alter undefined entity '${entityName}'. Define it first using 'define-entity ${entityName}'.`,\n            file,\n            location: entry.location,\n            sourceMap,\n            data: { entityName },\n          });\n        }\n      }\n    }\n  },\n};\n\n/**\n * Check for alter-entity entries targeting entities that were never defined\n */\nexport const alterUndefinedEntityRule: Rule = {\n  code: \"alter-undefined-entity\",\n  name: \"Alter Undefined Entity\",\n  description: \"alter-entity targets an undefined entity\",\n  category,\n  defaultSeverity: \"error\",\n  dependencies: { scope: \"workspace\", schemas: true },\n  visitor,\n};\n"],"mappings":";AAGA,MAAMA,WAAyB;AAE/B,MAAMC,UAAuB,EAC3B,WAAW,KAAqB;CAC9B,MAAM,EAAE,UAAU;CAGlB,MAAM,kBAAkB,IAAI,IAAI,MAAM,qBAAqB,MAAM,CAAC;AAGlE,MAAK,MAAM,CAAC,YAAY,WAAW,MAAM,oBACvC,KAAI,CAAC,gBAAgB,IAAI,WAAW,CAClC,MAAK,MAAM,EAAE,OAAO,MAAM,eAAe,OACvC,KAAI,OAAO;EACT,SAAS,kCAAkC,WAAW,0CAA0C,WAAW;EAC3G;EACA,UAAU,MAAM;EAChB;EACA,MAAM,EAAE,YAAY;EACrB,CAAC;GAKX;;;;AAKD,MAAaC,2BAAiC;CAC5C,MAAM;CACN,MAAM;CACN,aAAa;CACb;CACA,iBAAiB;CACjB,cAAc;EAAE,OAAO;EAAa,SAAS;EAAM;CACnD;CACD"}

package/dist/checker/rules/create-requires-section.js

@@ -0,0 +1,34 @@
+//#region src/checker/rules/create-requires-section.ts
+const category = "instance";
+const visitor = { visitInstanceEntry(entry, ctx) {
+	if (entry.header.directive !== "create") return;
+	if ((entry.content?.children.filter((c) => c.type === "markdown_header").length ?? 0) === 0) {
+		const title = entry.header.title?.value ?? "(no title)";
+		ctx.report({
+			message: `Create entry '${title}' must use at least one section.`,
+			file: ctx.file,
+			location: entry.location,
+			sourceMap: ctx.sourceMap,
+			data: {
+				title,
+				entity: entry.header.entity
+			}
+		});
+	}
+} };
+/**
+* Check that create entries have at least one section in their content
+*/
+const createRequiresSectionRule = {
+	code: "create-requires-section",
+	name: "Create Requires Section",
+	description: "Create entry must use at least one section",
+	category,
+	defaultSeverity: "error",
+	dependencies: { scope: "entry" },
+	visitor
+};
+
+//#endregion
+export { createRequiresSectionRule };
+//# sourceMappingURL=create-requires-section.js.map

package/dist/checker/rules/create-requires-section.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-requires-section.js","names":["category: RuleCategory","visitor: RuleVisitor","createRequiresSectionRule: Rule"],"sources":["../../../src/checker/rules/create-requires-section.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    if (entry.header.directive !== \"create\") {\n      return;\n    }\n\n    // Count markdown headers (sections) in content\n    const content = entry.content;\n    const sectionCount = content?.children.filter((c) => c.type === \"markdown_header\").length ?? 0;\n\n    if (sectionCount === 0) {\n      const title = entry.header.title?.value ?? \"(no title)\";\n      ctx.report({\n        message: `Create entry '${title}' must use at least one section.`,\n        file: ctx.file,\n        location: entry.location,\n        sourceMap: ctx.sourceMap,\n        data: { title, entity: entry.header.entity },\n      });\n    }\n  },\n};\n\n/**\n * Check that create entries have at least one section in their content\n */\nexport const createRequiresSectionRule: Rule = {\n  code: \"create-requires-section\",\n  name: \"Create Requires Section\",\n  description: \"Create entry must use at least one section\",\n  category,\n  defaultSeverity: \"error\",\n  dependencies: { scope: \"entry\" },\n  visitor,\n};\n"],"mappings":";AAGA,MAAMA,WAAyB;AAE/B,MAAMC,UAAuB,EAC3B,mBAAmB,OAAO,KAAK;AAC7B,KAAI,MAAM,OAAO,cAAc,SAC7B;AAOF,MAHgB,MAAM,SACQ,SAAS,QAAQ,MAAM,EAAE,SAAS,kBAAkB,CAAC,UAAU,OAExE,GAAG;EACtB,MAAM,QAAQ,MAAM,OAAO,OAAO,SAAS;AAC3C,MAAI,OAAO;GACT,SAAS,iBAAiB,MAAM;GAChC,MAAM,IAAI;GACV,UAAU,MAAM;GAChB,WAAW,IAAI;GACf,MAAM;IAAE;IAAO,QAAQ,MAAM,OAAO;IAAQ;GAC7C,CAAC;;GAGP;;;;AAKD,MAAaC,4BAAkC;CAC7C,MAAM;CACN,MAAM;CACN,aAAa;CACb;CACA,iBAAiB;CACjB,cAAc,EAAE,OAAO,SAAS;CAChC;CACD"}

package/dist/checker/rules/define-entity-requires-section.js

@@ -0,0 +1,31 @@
+//#region src/checker/rules/define-entity-requires-section.ts
+const category = "schema";
+const visitor = { visitSchemaEntry(entry, ctx) {
+	if (entry.header.directive !== "define-entity") return;
+	if ((entry.sectionsBlock?.sections.length ?? 0) === 0) {
+		const entityName = entry.header.entityName.value;
+		ctx.report({
+			message: `Entity definition '${entityName}' must have at least one section.`,
+			file: ctx.file,
+			location: entry.location,
+			sourceMap: ctx.sourceMap,
+			data: { entityName }
+		});
+	}
+} };
+/**
+* Check that define-entity entries have at least one section defined
+*/
+const defineEntityRequiresSectionRule = {
+	code: "define-entity-requires-section",
+	name: "Define Entity Requires Section",
+	description: "Entity definition must have at least one section",
+	category,
+	defaultSeverity: "error",
+	dependencies: { scope: "entry" },
+	visitor
+};
+
+//#endregion
+export { defineEntityRequiresSectionRule };
+//# sourceMappingURL=define-entity-requires-section.js.map

package/dist/checker/rules/define-entity-requires-section.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-entity-requires-section.js","names":["category: RuleCategory","visitor: RuleVisitor","defineEntityRequiresSectionRule: Rule"],"sources":["../../../src/checker/rules/define-entity-requires-section.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\nimport type { RuleVisitor } from \"../visitor.js\";\n\nconst category: RuleCategory = \"schema\";\n\nconst visitor: RuleVisitor = {\n  visitSchemaEntry(entry, ctx) {\n    if (entry.header.directive !== \"define-entity\") {\n      return;\n    }\n\n    const sectionCount = entry.sectionsBlock?.sections.length ?? 0;\n    if (sectionCount === 0) {\n      const entityName = entry.header.entityName.value;\n      ctx.report({\n        message: `Entity definition '${entityName}' must have at least one section.`,\n        file: ctx.file,\n        location: entry.location,\n        sourceMap: ctx.sourceMap,\n        data: { entityName },\n      });\n    }\n  },\n};\n\n/**\n * Check that define-entity entries have at least one section defined\n */\nexport const defineEntityRequiresSectionRule: Rule = {\n  code: \"define-entity-requires-section\",\n  name: \"Define Entity Requires Section\",\n  description: \"Entity definition must have at least one section\",\n  category,\n  defaultSeverity: \"error\",\n  dependencies: { scope: \"entry\" },\n  visitor,\n};\n"],"mappings":";AAGA,MAAMA,WAAyB;AAE/B,MAAMC,UAAuB,EAC3B,iBAAiB,OAAO,KAAK;AAC3B,KAAI,MAAM,OAAO,cAAc,gBAC7B;AAIF,MADqB,MAAM,eAAe,SAAS,UAAU,OACxC,GAAG;EACtB,MAAM,aAAa,MAAM,OAAO,WAAW;AAC3C,MAAI,OAAO;GACT,SAAS,sBAAsB,WAAW;GAC1C,MAAM,IAAI;GACV,UAAU,MAAM;GAChB,WAAW,IAAI;GACf,MAAM,EAAE,YAAY;GACrB,CAAC;;GAGP;;;;AAKD,MAAaC,kCAAwC;CACnD,MAAM;CACN,MAAM;CACN,aAAa;CACb;CACA,iBAAiB;CACjB,cAAc,EAAE,OAAO,SAAS;CAChC;CACD"}

package/dist/checker/rules/duplicate-entity-definition.js

@@ -0,0 +1,37 @@
+//#region src/checker/rules/duplicate-entity-definition.ts
+const category = "schema";
+const visitor = { afterCheck(ctx) {
+	const { index } = ctx;
+	for (const [entityName, defs] of index.defineEntitiesByName) if (defs.length > 1) for (const { entry, file, sourceMap } of defs) {
+		const otherLocations = defs.filter((d) => d.entry !== entry).map((d) => `${d.file}:${d.entry.location.startPosition.row + 1}`).join(", ");
+		ctx.report({
+			message: `Duplicate definition for entity '${entityName}'. Also defined at: ${otherLocations}`,
+			file,
+			location: entry.location,
+			sourceMap,
+			data: {
+				entityName,
+				otherLocations
+			}
+		});
+	}
+} };
+/**
+* Check for multiple define-entity entries for the same entity name
+*/
+const duplicateEntityDefinitionRule = {
+	code: "duplicate-entity-definition",
+	name: "Duplicate Entity Definition",
+	description: "Multiple define-entity for the same entity name",
+	category,
+	defaultSeverity: "error",
+	dependencies: {
+		scope: "workspace",
+		schemas: true
+	},
+	visitor
+};
+
+//#endregion
+export { duplicateEntityDefinitionRule };
+//# sourceMappingURL=duplicate-entity-definition.js.map

package/dist/checker/rules/duplicate-entity-definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-entity-definition.js","names":["category: RuleCategory","visitor: RuleVisitor","duplicateEntityDefinitionRule: Rule"],"sources":["../../../src/checker/rules/duplicate-entity-definition.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\nimport type { RuleVisitor, VisitorContext } from \"../visitor.js\";\n\nconst category: RuleCategory = \"schema\";\n\nconst visitor: RuleVisitor = {\n  afterCheck(ctx: VisitorContext) {\n    const { index } = ctx;\n\n    // Report duplicates\n    for (const [entityName, defs] of index.defineEntitiesByName) {\n      if (defs.length > 1) {\n        for (const { entry, file, sourceMap } of defs) {\n          const otherLocations = defs\n            .filter((d) => d.entry !== entry)\n            .map((d) => `${d.file}:${d.entry.location.startPosition.row + 1}`)\n            .join(\", \");\n\n          ctx.report({\n            message: `Duplicate definition for entity '${entityName}'. Also defined at: ${otherLocations}`,\n            file,\n            location: entry.location,\n            sourceMap,\n            data: { entityName, otherLocations },\n          });\n        }\n      }\n    }\n  },\n};\n\n/**\n * Check for multiple define-entity entries for the same entity name\n */\nexport const duplicateEntityDefinitionRule: Rule = {\n  code: \"duplicate-entity-definition\",\n  name: \"Duplicate Entity Definition\",\n  description: \"Multiple define-entity for the same entity name\",\n  category,\n  defaultSeverity: \"error\",\n  dependencies: { scope: \"workspace\", schemas: true },\n  visitor,\n};\n"],"mappings":";AAGA,MAAMA,WAAyB;AAE/B,MAAMC,UAAuB,EAC3B,WAAW,KAAqB;CAC9B,MAAM,EAAE,UAAU;AAGlB,MAAK,MAAM,CAAC,YAAY,SAAS,MAAM,qBACrC,KAAI,KAAK,SAAS,EAChB,MAAK,MAAM,EAAE,OAAO,MAAM,eAAe,MAAM;EAC7C,MAAM,iBAAiB,KACpB,QAAQ,MAAM,EAAE,UAAU,MAAM,CAChC,KAAK,MAAM,GAAG,EAAE,KAAK,GAAG,EAAE,MAAM,SAAS,cAAc,MAAM,IAAI,CACjE,KAAK,KAAK;AAEb,MAAI,OAAO;GACT,SAAS,oCAAoC,WAAW,sBAAsB;GAC9E;GACA,UAAU,MAAM;GAChB;GACA,MAAM;IAAE;IAAY;IAAgB;GACrC,CAAC;;GAKX;;;;AAKD,MAAaC,gCAAsC;CACjD,MAAM;CACN,MAAM;CACN,aAAa;CACb;CACA,iBAAiB;CACjB,cAAc;EAAE,OAAO;EAAa,SAAS;EAAM;CACnD;CACD"}

package/dist/checker/rules/duplicate-field-in-schema.js

@@ -0,0 +1,38 @@
+//#region src/checker/rules/duplicate-field-in-schema.ts
+const category = "schema";
+const visitor = { visitSchemaEntry(entry, ctx) {
+	const fields = entry.metadataBlock?.fields ?? [];
+	const seenFields = /* @__PURE__ */ new Map();
+	for (const field of fields) {
+		const fieldName = field.name.value;
+		const fieldLine = field.location?.startPosition.row ?? 0;
+		const existingLine = seenFields.get(fieldName);
+		if (existingLine !== void 0) ctx.report({
+			message: `Duplicate field '${fieldName}' in schema entry. First defined at line ${existingLine}.`,
+			file: ctx.file,
+			location: field.location,
+			sourceMap: ctx.sourceMap,
+			data: {
+				fieldName,
+				firstLine: existingLine
+			}
+		});
+		else seenFields.set(fieldName, fieldLine + 1);
+	}
+} };
+/**
+* Check for duplicate field names within a single schema entry
+*/
+const duplicateFieldInSchemaRule = {
+	code: "duplicate-field-in-schema",
+	name: "Duplicate Field in Schema",
+	description: "Same field defined twice in a schema entry",
+	category,
+	defaultSeverity: "error",
+	dependencies: { scope: "entry" },
+	visitor
+};
+
+//#endregion
+export { duplicateFieldInSchemaRule };
+//# sourceMappingURL=duplicate-field-in-schema.js.map

package/dist/checker/rules/duplicate-field-in-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-field-in-schema.js","names":["category: RuleCategory","visitor: RuleVisitor","duplicateFieldInSchemaRule: Rule"],"sources":["../../../src/checker/rules/duplicate-field-in-schema.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\nimport type { RuleVisitor } from \"../visitor.js\";\n\nconst category: RuleCategory = \"schema\";\n\nconst visitor: RuleVisitor = {\n  visitSchemaEntry(entry, ctx) {\n    const fields = entry.metadataBlock?.fields ?? [];\n    const seenFields = new Map<string, number>();\n\n    for (const field of fields) {\n      const fieldName = field.name.value;\n      const fieldLine = field.location?.startPosition.row ?? 0;\n      const existingLine = seenFields.get(fieldName);\n\n      if (existingLine !== undefined) {\n        ctx.report({\n          message: `Duplicate field '${fieldName}' in schema entry. First defined at line ${existingLine}.`,\n          file: ctx.file,\n          location: field.location,\n          sourceMap: ctx.sourceMap,\n          data: { fieldName, firstLine: existingLine },\n        });\n      } else {\n        seenFields.set(fieldName, fieldLine + 1);\n      }\n    }\n  },\n};\n\n/**\n * Check for duplicate field names within a single schema entry\n */\nexport const duplicateFieldInSchemaRule: Rule = {\n  code: \"duplicate-field-in-schema\",\n  name: \"Duplicate Field in Schema\",\n  description: \"Same field defined twice in a schema entry\",\n  category,\n  defaultSeverity: \"error\",\n  dependencies: { scope: \"entry\" },\n  visitor,\n};\n"],"mappings":";AAGA,MAAMA,WAAyB;AAE/B,MAAMC,UAAuB,EAC3B,iBAAiB,OAAO,KAAK;CAC3B,MAAM,SAAS,MAAM,eAAe,UAAU,EAAE;CAChD,MAAM,6BAAa,IAAI,KAAqB;AAE5C,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,YAAY,MAAM,KAAK;EAC7B,MAAM,YAAY,MAAM,UAAU,cAAc,OAAO;EACvD,MAAM,eAAe,WAAW,IAAI,UAAU;AAE9C,MAAI,iBAAiB,OACnB,KAAI,OAAO;GACT,SAAS,oBAAoB,UAAU,2CAA2C,aAAa;GAC/F,MAAM,IAAI;GACV,UAAU,MAAM;GAChB,WAAW,IAAI;GACf,MAAM;IAAE;IAAW,WAAW;IAAc;GAC7C,CAAC;MAEF,YAAW,IAAI,WAAW,YAAY,EAAE;;GAI/C;;;;AAKD,MAAaC,6BAAmC;CAC9C,MAAM;CACN,MAAM;CACN,aAAa;CACb;CACA,iBAAiB;CACjB,cAAc,EAAE,OAAO,SAAS;CAChC;CACD"}

package/dist/checker/rules/duplicate-link-id.js

@@ -0,0 +1,52 @@
+//#region src/checker/rules/duplicate-link-id.ts
+const category = "link";
+const visitor = { afterCheck(ctx) {
+	const { workspace } = ctx;
+	const definitionsByLinkId = /* @__PURE__ */ new Map();
+	for (const model of workspace.allModels()) for (const [linkId, def] of model.linkIndex.definitions) {
+		const defs = definitionsByLinkId.get(linkId) ?? [];
+		defs.push(def);
+		definitionsByLinkId.set(linkId, defs);
+	}
+	for (const [linkId, defs] of definitionsByLinkId) if (defs.length > 1) {
+		const explicitDefs = defs.filter((d) => {
+			const entry = d.entry;
+			if (entry.type === "instance_entry" || entry.type === "schema_entry") return entry.header.link?.id === linkId;
+			if (entry.type === "synthesis_entry") return entry.header.linkId.id === linkId;
+			return false;
+		});
+		if (explicitDefs.length > 1) for (const def of explicitDefs) {
+			const model = workspace.getModel(def.file);
+			const otherFiles = explicitDefs.filter((d) => d !== def).map((d) => d.file).join(", ");
+			ctx.report({
+				message: `Duplicate link ID '^${linkId}'. Also defined in: ${otherFiles}`,
+				file: def.file,
+				location: def.location,
+				sourceMap: model?.sourceMap,
+				data: {
+					linkId,
+					otherFiles
+				}
+			});
+		}
+	}
+} };
+/**
+* Check for duplicate link ID definitions
+*/
+const duplicateLinkIdRule = {
+	code: "duplicate-link-id",
+	name: "Duplicate Link ID",
+	description: "Same explicit ^link-id defined multiple times",
+	category,
+	defaultSeverity: "error",
+	dependencies: {
+		scope: "workspace",
+		links: true
+	},
+	visitor
+};
+
+//#endregion
+export { duplicateLinkIdRule };
+//# sourceMappingURL=duplicate-link-id.js.map

package/dist/checker/rules/duplicate-link-id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-link-id.js","names":["category: RuleCategory","visitor: RuleVisitor","duplicateLinkIdRule: Rule"],"sources":["../../../src/checker/rules/duplicate-link-id.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\nimport type { RuleVisitor, VisitorContext } from \"../visitor.js\";\nimport type { LinkDefinition } from \"../../semantic/analyzer.js\";\n\nconst category: RuleCategory = \"link\";\n\nconst visitor: RuleVisitor = {\n  afterCheck(ctx: VisitorContext) {\n    const { workspace } = ctx;\n\n    // Track all definitions we've seen for each link ID\n    const definitionsByLinkId = new Map<string, LinkDefinition[]>();\n\n    // Collect definitions from all models\n    for (const model of workspace.allModels()) {\n      for (const [linkId, def] of model.linkIndex.definitions) {\n        const defs = definitionsByLinkId.get(linkId) ?? [];\n        defs.push(def);\n        definitionsByLinkId.set(linkId, defs);\n      }\n    }\n\n    // Report duplicates\n    for (const [linkId, defs] of definitionsByLinkId) {\n      if (defs.length > 1) {\n        // Skip timestamps - they're implicitly unique per entry\n        // Only report explicit ^link-id duplicates\n        const explicitDefs = defs.filter((d) => {\n          const entry = d.entry;\n          if (entry.type === \"instance_entry\" || entry.type === \"schema_entry\") {\n            return entry.header.link?.id === linkId;\n          }\n          if (entry.type === \"synthesis_entry\") {\n            return entry.header.linkId.id === linkId;\n          }\n          return false;\n        });\n\n        if (explicitDefs.length > 1) {\n          for (const def of explicitDefs) {\n            const model = workspace.getModel(def.file);\n            const otherFiles = explicitDefs\n              .filter((d) => d !== def)\n              .map((d) => d.file)\n              .join(\", \");\n\n            ctx.report({\n              message: `Duplicate link ID '^${linkId}'. Also defined in: ${otherFiles}`,\n              file: def.file,\n              location: def.location,\n              sourceMap: model?.sourceMap,\n              data: { linkId, otherFiles },\n            });\n          }\n        }\n      }\n    }\n  },\n};\n\n/**\n * Check for duplicate link ID definitions\n */\nexport const duplicateLinkIdRule: Rule = {\n  code: \"duplicate-link-id\",\n  name: \"Duplicate Link ID\",\n  description: \"Same explicit ^link-id defined multiple times\",\n  category,\n  defaultSeverity: \"error\",\n  dependencies: { scope: \"workspace\", links: true },\n  visitor,\n};\n"],"mappings":";AAIA,MAAMA,WAAyB;AAE/B,MAAMC,UAAuB,EAC3B,WAAW,KAAqB;CAC9B,MAAM,EAAE,cAAc;CAGtB,MAAM,sCAAsB,IAAI,KAA+B;AAG/D,MAAK,MAAM,SAAS,UAAU,WAAW,CACvC,MAAK,MAAM,CAAC,QAAQ,QAAQ,MAAM,UAAU,aAAa;EACvD,MAAM,OAAO,oBAAoB,IAAI,OAAO,IAAI,EAAE;AAClD,OAAK,KAAK,IAAI;AACd,sBAAoB,IAAI,QAAQ,KAAK;;AAKzC,MAAK,MAAM,CAAC,QAAQ,SAAS,oBAC3B,KAAI,KAAK,SAAS,GAAG;EAGnB,MAAM,eAAe,KAAK,QAAQ,MAAM;GACtC,MAAM,QAAQ,EAAE;AAChB,OAAI,MAAM,SAAS,oBAAoB,MAAM,SAAS,eACpD,QAAO,MAAM,OAAO,MAAM,OAAO;AAEnC,OAAI,MAAM,SAAS,kBACjB,QAAO,MAAM,OAAO,OAAO,OAAO;AAEpC,UAAO;IACP;AAEF,MAAI,aAAa,SAAS,EACxB,MAAK,MAAM,OAAO,cAAc;GAC9B,MAAM,QAAQ,UAAU,SAAS,IAAI,KAAK;GAC1C,MAAM,aAAa,aAChB,QAAQ,MAAM,MAAM,IAAI,CACxB,KAAK,MAAM,EAAE,KAAK,CAClB,KAAK,KAAK;AAEb,OAAI,OAAO;IACT,SAAS,uBAAuB,OAAO,sBAAsB;IAC7D,MAAM,IAAI;IACV,UAAU,IAAI;IACd,WAAW,OAAO;IAClB,MAAM;KAAE;KAAQ;KAAY;IAC7B,CAAC;;;GAMb;;;;AAKD,MAAaC,sBAA4B;CACvC,MAAM;CACN,MAAM;CACN,aAAa;CACb;CACA,iBAAiB;CACjB,cAAc;EAAE,OAAO;EAAa,OAAO;EAAM;CACjD;CACD"}

package/dist/checker/rules/duplicate-metadata-key.js

@@ -0,0 +1,21 @@
+//#region src/checker/rules/duplicate-metadata-key.ts
+const category = "metadata";
+/**
+* Check for duplicate metadata keys within a single instance entry
+*
+* Note: This rule is a placeholder. The parser collapses duplicate keys into a Map,
+* so detection would require AST-level checking before model extraction.
+*/
+const duplicateMetadataKeyRule = {
+	code: "duplicate-metadata-key",
+	name: "Duplicate Metadata Key",
+	description: "Same metadata key appears twice in an entry",
+	category,
+	defaultSeverity: "error",
+	dependencies: { scope: "entry" },
+	visitor: {}
+};
+
+//#endregion
+export { duplicateMetadataKeyRule };
+//# sourceMappingURL=duplicate-metadata-key.js.map

package/dist/checker/rules/duplicate-metadata-key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-metadata-key.js","names":["category: RuleCategory","duplicateMetadataKeyRule: Rule"],"sources":["../../../src/checker/rules/duplicate-metadata-key.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\n\nconst category: RuleCategory = \"metadata\";\n\n/**\n * Check for duplicate metadata keys within a single instance entry\n *\n * Note: This rule is a placeholder. The parser collapses duplicate keys into a Map,\n * so detection would require AST-level checking before model extraction.\n */\nexport const duplicateMetadataKeyRule: Rule = {\n  code: \"duplicate-metadata-key\",\n  name: \"Duplicate Metadata Key\",\n  description: \"Same metadata key appears twice in an entry\",\n  category,\n  defaultSeverity: \"error\",\n  dependencies: { scope: \"entry\" },\n  visitor: {},\n};\n"],"mappings":";AAEA,MAAMA,WAAyB;;;;;;;AAQ/B,MAAaC,2BAAiC;CAC5C,MAAM;CACN,MAAM;CACN,aAAa;CACb;CACA,iBAAiB;CACjB,cAAc,EAAE,OAAO,SAAS;CAChC,SAAS,EAAE;CACZ"}

package/dist/checker/rules/duplicate-section-heading.js

@@ -0,0 +1,41 @@
+//#region src/checker/rules/duplicate-section-heading.ts
+const category = "content";
+/**
+* Extract markdown headers from entry content
+*/
+function getMarkdownHeaders(entry) {
+	if (!entry.content) return [];
+	return entry.content.children.filter((c) => c.type === "markdown_header");
+}
+const visitor = { visitInstanceEntry(entry, ctx) {
+	const headers = getMarkdownHeaders(entry);
+	const seenSections = /* @__PURE__ */ new Map();
+	for (const header of headers) {
+		const match = header.text.match(/^#+\s*(.+)$/);
+		const sectionName = match ? match[1].trim() : header.text;
+		if (seenSections.get(sectionName)) ctx.report({
+			message: `Duplicate section heading '# ${sectionName}' in entry content.`,
+			file: ctx.file,
+			location: header.location,
+			sourceMap: ctx.sourceMap,
+			data: { sectionName }
+		});
+		else seenSections.set(sectionName, header);
+	}
+} };
+/**
+* Check for duplicate section headings within a single entry's content
+*/
+const duplicateSectionHeadingRule = {
+	code: "duplicate-section-heading",
+	name: "Duplicate Section Heading",
+	description: "Same # Section appears twice in entry content",
+	category,
+	defaultSeverity: "error",
+	dependencies: { scope: "entry" },
+	visitor
+};
+
+//#endregion
+export { duplicateSectionHeadingRule };
+//# sourceMappingURL=duplicate-section-heading.js.map

package/dist/checker/rules/duplicate-section-heading.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-section-heading.js","names":["category: RuleCategory","visitor: RuleVisitor","duplicateSectionHeadingRule: Rule"],"sources":["../../../src/checker/rules/duplicate-section-heading.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\nimport type { RuleVisitor } from \"../visitor.js\";\nimport type { InstanceEntry, MarkdownHeader } from \"../../ast/ast-types.js\";\n\nconst category: RuleCategory = \"content\";\n\n/**\n * Extract markdown headers from entry content\n */\nfunction getMarkdownHeaders(entry: InstanceEntry): MarkdownHeader[] {\n  if (!entry.content) {\n    return [];\n  }\n  return entry.content.children.filter((c): c is MarkdownHeader => c.type === \"markdown_header\");\n}\n\nconst visitor: RuleVisitor = {\n  visitInstanceEntry(entry, ctx) {\n    const headers = getMarkdownHeaders(entry);\n    const seenSections = new Map<string, MarkdownHeader>();\n\n    for (const header of headers) {\n      // Extract section name from \"# SectionName\" format\n      const match = header.text.match(/^#+\\s*(.+)$/);\n      const sectionName = match ? match[1].trim() : header.text;\n      const existing = seenSections.get(sectionName);\n\n      if (existing) {\n        ctx.report({\n          message: `Duplicate section heading '# ${sectionName}' in entry content.`,\n          file: ctx.file,\n          location: header.location,\n          sourceMap: ctx.sourceMap,\n          data: { sectionName },\n        });\n      } else {\n        seenSections.set(sectionName, header);\n      }\n    }\n  },\n};\n\n/**\n * Check for duplicate section headings within a single entry's content\n */\nexport const duplicateSectionHeadingRule: Rule = {\n  code: \"duplicate-section-heading\",\n  name: \"Duplicate Section Heading\",\n  description: \"Same # Section appears twice in entry content\",\n  category,\n  defaultSeverity: \"error\",\n  dependencies: { scope: \"entry\" },\n  visitor,\n};\n"],"mappings":";AAIA,MAAMA,WAAyB;;;;AAK/B,SAAS,mBAAmB,OAAwC;AAClE,KAAI,CAAC,MAAM,QACT,QAAO,EAAE;AAEX,QAAO,MAAM,QAAQ,SAAS,QAAQ,MAA2B,EAAE,SAAS,kBAAkB;;AAGhG,MAAMC,UAAuB,EAC3B,mBAAmB,OAAO,KAAK;CAC7B,MAAM,UAAU,mBAAmB,MAAM;CACzC,MAAM,+BAAe,IAAI,KAA6B;AAEtD,MAAK,MAAM,UAAU,SAAS;EAE5B,MAAM,QAAQ,OAAO,KAAK,MAAM,cAAc;EAC9C,MAAM,cAAc,QAAQ,MAAM,GAAG,MAAM,GAAG,OAAO;AAGrD,MAFiB,aAAa,IAAI,YAAY,CAG5C,KAAI,OAAO;GACT,SAAS,gCAAgC,YAAY;GACrD,MAAM,IAAI;GACV,UAAU,OAAO;GACjB,WAAW,IAAI;GACf,MAAM,EAAE,aAAa;GACtB,CAAC;MAEF,cAAa,IAAI,aAAa,OAAO;;GAI5C;;;;AAKD,MAAaC,8BAAoC;CAC/C,MAAM;CACN,MAAM;CACN,aAAa;CACb;CACA,iBAAiB;CACjB,cAAc,EAAE,OAAO,SAAS;CAChC;CACD"}

package/dist/checker/rules/duplicate-section-in-schema.js

@@ -0,0 +1,38 @@
+//#region src/checker/rules/duplicate-section-in-schema.ts
+const category = "schema";
+const visitor = { visitSchemaEntry(entry, ctx) {
+	const sections = entry.sectionsBlock?.sections ?? [];
+	const seenSections = /* @__PURE__ */ new Map();
+	for (const section of sections) {
+		const sectionName = section.name.value;
+		const sectionLine = section.location?.startPosition.row ?? 0;
+		const existingLine = seenSections.get(sectionName);
+		if (existingLine !== void 0) ctx.report({
+			message: `Duplicate section '${sectionName}' in schema entry. First defined at line ${existingLine}.`,
+			file: ctx.file,
+			location: section.location,
+			sourceMap: ctx.sourceMap,
+			data: {
+				sectionName,
+				firstLine: existingLine
+			}
+		});
+		else seenSections.set(sectionName, sectionLine + 1);
+	}
+} };
+/**
+* Check for duplicate section names within a single schema entry
+*/
+const duplicateSectionInSchemaRule = {
+	code: "duplicate-section-in-schema",
+	name: "Duplicate Section in Schema",
+	description: "Same section defined twice in a schema entry",
+	category,
+	defaultSeverity: "error",
+	dependencies: { scope: "entry" },
+	visitor
+};
+
+//#endregion
+export { duplicateSectionInSchemaRule };
+//# sourceMappingURL=duplicate-section-in-schema.js.map

package/dist/checker/rules/duplicate-section-in-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-section-in-schema.js","names":["category: RuleCategory","visitor: RuleVisitor","duplicateSectionInSchemaRule: Rule"],"sources":["../../../src/checker/rules/duplicate-section-in-schema.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\nimport type { RuleVisitor } from \"../visitor.js\";\n\nconst category: RuleCategory = \"schema\";\n\nconst visitor: RuleVisitor = {\n  visitSchemaEntry(entry, ctx) {\n    const sections = entry.sectionsBlock?.sections ?? [];\n    const seenSections = new Map<string, number>();\n\n    for (const section of sections) {\n      const sectionName = section.name.value;\n      const sectionLine = section.location?.startPosition.row ?? 0;\n      const existingLine = seenSections.get(sectionName);\n\n      if (existingLine !== undefined) {\n        ctx.report({\n          message: `Duplicate section '${sectionName}' in schema entry. First defined at line ${existingLine}.`,\n          file: ctx.file,\n          location: section.location,\n          sourceMap: ctx.sourceMap,\n          data: { sectionName, firstLine: existingLine },\n        });\n      } else {\n        seenSections.set(sectionName, sectionLine + 1);\n      }\n    }\n  },\n};\n\n/**\n * Check for duplicate section names within a single schema entry\n */\nexport const duplicateSectionInSchemaRule: Rule = {\n  code: \"duplicate-section-in-schema\",\n  name: \"Duplicate Section in Schema\",\n  description: \"Same section defined twice in a schema entry\",\n  category,\n  defaultSeverity: \"error\",\n  dependencies: { scope: \"entry\" },\n  visitor,\n};\n"],"mappings":";AAGA,MAAMA,WAAyB;AAE/B,MAAMC,UAAuB,EAC3B,iBAAiB,OAAO,KAAK;CAC3B,MAAM,WAAW,MAAM,eAAe,YAAY,EAAE;CACpD,MAAM,+BAAe,IAAI,KAAqB;AAE9C,MAAK,MAAM,WAAW,UAAU;EAC9B,MAAM,cAAc,QAAQ,KAAK;EACjC,MAAM,cAAc,QAAQ,UAAU,cAAc,OAAO;EAC3D,MAAM,eAAe,aAAa,IAAI,YAAY;AAElD,MAAI,iBAAiB,OACnB,KAAI,OAAO;GACT,SAAS,sBAAsB,YAAY,2CAA2C,aAAa;GACnG,MAAM,IAAI;GACV,UAAU,QAAQ;GAClB,WAAW,IAAI;GACf,MAAM;IAAE;IAAa,WAAW;IAAc;GAC/C,CAAC;MAEF,cAAa,IAAI,aAAa,cAAc,EAAE;;GAIrD;;;;AAKD,MAAaC,+BAAqC;CAChD,MAAM;CACN,MAAM;CACN,aAAa;CACb;CACA,iBAAiB;CACjB,cAAc,EAAE,OAAO,SAAS;CAChC;CACD"}

package/dist/checker/rules/duplicate-timestamp.js

@@ -0,0 +1,104 @@
+//#region src/checker/rules/duplicate-timestamp.ts
+const category = "instance";
+const visitor = { afterCheck(ctx) {
+	const { workspace } = ctx;
+	for (const model of workspace.allModels()) {
+		const entriesByIdentity = /* @__PURE__ */ new Map();
+		for (const entry of model.ast.entries) {
+			const timestamp = getEntryTimestamp(entry);
+			if (!timestamp) continue;
+			if (hasExplicitLinkId(entry)) continue;
+			const identityKey = `${timestamp}|${entry.type}`;
+			const entries = entriesByIdentity.get(identityKey) ?? [];
+			entries.push(entry);
+			entriesByIdentity.set(identityKey, entries);
+		}
+		for (const [identityKey, entries] of entriesByIdentity) if (entries.length > 1) {
+			const [timestamp, entryType] = identityKey.split("|");
+			const entryTypeName = formatEntryType(entryType);
+			for (const entry of entries) ctx.report({
+				message: `Duplicate timestamp '${timestamp}' for ${entryTypeName} without explicit ^link-id. Add a unique ^link-id to disambiguate entries with the same timestamp.`,
+				file: model.file,
+				location: getTimestampLocation(entry),
+				sourceMap: model.sourceMap,
+				data: {
+					timestamp,
+					entryType,
+					duplicateCount: entries.length
+				}
+			});
+		}
+	}
+} };
+/**
+* Get timestamp string from an entry
+*/
+function getEntryTimestamp(entry) {
+	switch (entry.type) {
+		case "instance_entry":
+		case "schema_entry":
+		case "synthesis_entry":
+		case "actualize_entry": return entry.header.timestamp.value;
+		default: return null;
+	}
+}
+/**
+* Check if entry has an explicit link ID
+*/
+function hasExplicitLinkId(entry) {
+	switch (entry.type) {
+		case "instance_entry":
+		case "schema_entry": return entry.header.link !== null;
+		case "synthesis_entry": return true;
+		case "actualize_entry": return true;
+		default: return false;
+	}
+}
+/**
+* Get the location of the timestamp in an entry (for error reporting)
+*/
+function getTimestampLocation(entry) {
+	switch (entry.type) {
+		case "instance_entry":
+		case "schema_entry":
+		case "synthesis_entry":
+		case "actualize_entry": return entry.header.timestamp.location;
+		default: return entry.location;
+	}
+}
+/**
+* Format entry type for human-readable error messages
+*/
+function formatEntryType(entryType) {
+	switch (entryType) {
+		case "instance_entry": return "instance entry";
+		case "schema_entry": return "schema entry";
+		case "synthesis_entry": return "synthesis entry";
+		case "actualize_entry": return "actualize entry";
+		default: return entryType;
+	}
+}
+/**
+* Check for duplicate timestamps without link IDs
+*
+* When multiple entries in the same file have identical timestamps and the same
+* entry type, they must have explicit ^link-id values to be distinguished during
+* merge operations. Without link IDs, only the first entry will be used during
+* three-way merges, potentially causing data loss.
+*/
+const duplicateTimestampRule = {
+	code: "duplicate-timestamp",
+	name: "Duplicate Timestamp Without Link ID",
+	description: "Multiple entries with the same timestamp and type must have explicit ^link-id for merge disambiguation",
+	category,
+	defaultSeverity: "error",
+	dependencies: {
+		scope: "document",
+		links: false
+	},
+	visitor
+};
+
+//#endregion
+export { duplicateTimestampRule };
+//# sourceMappingURL=duplicate-timestamp.js.map

package/dist/checker/rules/duplicate-timestamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-timestamp.js","names":["category: RuleCategory","visitor: RuleVisitor","duplicateTimestampRule: Rule"],"sources":["../../../src/checker/rules/duplicate-timestamp.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\nimport type { RuleVisitor, VisitorContext } from \"../visitor.js\";\nimport type { Entry } from \"../../ast/ast-types.js\";\n\nconst category: RuleCategory = \"instance\";\n\nconst visitor: RuleVisitor = {\n  afterCheck(ctx: VisitorContext) {\n    const { workspace } = ctx;\n\n    // Check each file independently since timestamps are per-file\n    for (const model of workspace.allModels()) {\n      // Track entries by timestamp+type (the merge identity key)\n      const entriesByIdentity = new Map<string, Entry[]>();\n\n      for (const entry of model.ast.entries) {\n        // Get timestamp\n        const timestamp = getEntryTimestamp(entry);\n        if (!timestamp) {\n          continue;\n        }\n\n        // Check if entry has an explicit link ID\n        const hasLinkId = hasExplicitLinkId(entry);\n        if (hasLinkId) {\n          // Entries with link IDs are always uniquely identified\n          continue;\n        }\n\n        // Build identity key: timestamp|type (using | since timestamps contain :)\n        const identityKey = `${timestamp}|${entry.type}`;\n\n        const entries = entriesByIdentity.get(identityKey) ?? [];\n        entries.push(entry);\n        entriesByIdentity.set(identityKey, entries);\n      }\n\n      // Report duplicates\n      for (const [identityKey, entries] of entriesByIdentity) {\n        if (entries.length > 1) {\n          const [timestamp, entryType] = identityKey.split(\"|\");\n          const entryTypeName = formatEntryType(entryType);\n\n          for (const entry of entries) {\n            ctx.report({\n              message: `Duplicate timestamp '${timestamp}' for ${entryTypeName} without explicit ^link-id. Add a unique ^link-id to disambiguate entries with the same timestamp.`,\n              file: model.file,\n              location: getTimestampLocation(entry),\n              sourceMap: model.sourceMap,\n              data: { timestamp, entryType, duplicateCount: entries.length },\n            });\n          }\n        }\n      }\n    }\n  },\n};\n\n/**\n * Get timestamp string from an entry\n */\nfunction getEntryTimestamp(entry: Entry): string | null {\n  switch (entry.type) {\n    case \"instance_entry\":\n    case \"schema_entry\":\n    case \"synthesis_entry\":\n    case \"actualize_entry\":\n      return entry.header.timestamp.value;\n    default:\n      return null;\n  }\n}\n\n/**\n * Check if entry has an explicit link ID\n */\nfunction hasExplicitLinkId(entry: Entry): boolean {\n  switch (entry.type) {\n    case \"instance_entry\":\n    case \"schema_entry\":\n      return entry.header.link !== null;\n    case \"synthesis_entry\":\n      // Synthesis entries always have a required linkId\n      return true;\n    case \"actualize_entry\":\n      // Actualize entries use target, which is always present\n      return true;\n    default:\n      return false;\n  }\n}\n\n/**\n * Get the location of the timestamp in an entry (for error reporting)\n */\nfunction getTimestampLocation(entry: Entry): import(\"../../ast/ast-types.js\").Location {\n  switch (entry.type) {\n    case \"instance_entry\":\n    case \"schema_entry\":\n    case \"synthesis_entry\":\n    case \"actualize_entry\":\n      return entry.header.timestamp.location;\n    default: {\n      // This should never happen since all entry types have timestamps\n      const _exhaustive: never = entry;\n      return (_exhaustive as Entry).location;\n    }\n  }\n}\n\n/**\n * Format entry type for human-readable error messages\n */\nfunction formatEntryType(entryType: string): string {\n  switch (entryType) {\n    case \"instance_entry\":\n      return \"instance entry\";\n    case \"schema_entry\":\n      return \"schema entry\";\n    case \"synthesis_entry\":\n      return \"synthesis entry\";\n    case \"actualize_entry\":\n      return \"actualize entry\";\n    default:\n      return entryType;\n  }\n}\n\n/**\n * Check for duplicate timestamps without link IDs\n *\n * When multiple entries in the same file have identical timestamps and the same\n * entry type, they must have explicit ^link-id values to be distinguished during\n * merge operations. Without link IDs, only the first entry will be used during\n * three-way merges, potentially causing data loss.\n */\nexport const duplicateTimestampRule: Rule = {\n  code: \"duplicate-timestamp\",\n  name: \"Duplicate Timestamp Without Link ID\",\n  description:\n    \"Multiple entries with the same timestamp and type must have explicit ^link-id for merge disambiguation\",\n  category,\n  defaultSeverity: \"error\",\n  dependencies: { scope: \"document\", links: false },\n  visitor,\n};\n"],"mappings":";AAIA,MAAMA,WAAyB;AAE/B,MAAMC,UAAuB,EAC3B,WAAW,KAAqB;CAC9B,MAAM,EAAE,cAAc;AAGtB,MAAK,MAAM,SAAS,UAAU,WAAW,EAAE;EAEzC,MAAM,oCAAoB,IAAI,KAAsB;AAEpD,OAAK,MAAM,SAAS,MAAM,IAAI,SAAS;GAErC,MAAM,YAAY,kBAAkB,MAAM;AAC1C,OAAI,CAAC,UACH;AAKF,OADkB,kBAAkB,MAAM,CAGxC;GAIF,MAAM,cAAc,GAAG,UAAU,GAAG,MAAM;GAE1C,MAAM,UAAU,kBAAkB,IAAI,YAAY,IAAI,EAAE;AACxD,WAAQ,KAAK,MAAM;AACnB,qBAAkB,IAAI,aAAa,QAAQ;;AAI7C,OAAK,MAAM,CAAC,aAAa,YAAY,kBACnC,KAAI,QAAQ,SAAS,GAAG;GACtB,MAAM,CAAC,WAAW,aAAa,YAAY,MAAM,IAAI;GACrD,MAAM,gBAAgB,gBAAgB,UAAU;AAEhD,QAAK,MAAM,SAAS,QAClB,KAAI,OAAO;IACT,SAAS,wBAAwB,UAAU,QAAQ,cAAc;IACjE,MAAM,MAAM;IACZ,UAAU,qBAAqB,MAAM;IACrC,WAAW,MAAM;IACjB,MAAM;KAAE;KAAW;KAAW,gBAAgB,QAAQ;KAAQ;IAC/D,CAAC;;;GAMb;;;;AAKD,SAAS,kBAAkB,OAA6B;AACtD,SAAQ,MAAM,MAAd;EACE,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,kBACH,QAAO,MAAM,OAAO,UAAU;EAChC,QACE,QAAO;;;;;;AAOb,SAAS,kBAAkB,OAAuB;AAChD,SAAQ,MAAM,MAAd;EACE,KAAK;EACL,KAAK,eACH,QAAO,MAAM,OAAO,SAAS;EAC/B,KAAK,kBAEH,QAAO;EACT,KAAK,kBAEH,QAAO;EACT,QACE,QAAO;;;;;;AAOb,SAAS,qBAAqB,OAAyD;AACrF,SAAQ,MAAM,MAAd;EACE,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,kBACH,QAAO,MAAM,OAAO,UAAU;EAChC,QAGE,QAD2B,MACG;;;;;;AAQpC,SAAS,gBAAgB,WAA2B;AAClD,SAAQ,WAAR;EACE,KAAK,iBACH,QAAO;EACT,KAAK,eACH,QAAO;EACT,KAAK,kBACH,QAAO;EACT,KAAK,kBACH,QAAO;EACT,QACE,QAAO;;;;;;;;;;;AAYb,MAAaC,yBAA+B;CAC1C,MAAM;CACN,MAAM;CACN,aACE;CACF;CACA,iBAAiB;CACjB,cAAc;EAAE,OAAO;EAAY,OAAO;EAAO;CACjD;CACD"}

package/dist/checker/rules/empty-required-value.js

@@ -0,0 +1,45 @@
+//#region src/checker/rules/empty-required-value.ts
+const category = "metadata";
+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;
+		const fieldSchema = schema.fields.get(fieldName);
+		if (!fieldSchema) continue;
+		if (!fieldSchema.optional && fieldSchema.defaultValue === null) {
+			const rawValue = meta.value.raw.trim();
+			if (rawValue === "" || rawValue === "\"\"") ctx.report({
+				message: `Required field '${fieldName}' has an empty value.`,
+				file: ctx.file,
+				location: meta.value.location,
+				sourceMap: ctx.sourceMap,
+				data: {
+					fieldName,
+					entity
+				}
+			});
+		}
+	}
+} };
+/**
+* Check for required fields that are present but have empty values
+*/
+const emptyRequiredValueRule = {
+	code: "empty-required-value",
+	name: "Empty Required Value",
+	description: "Required field has empty value",
+	category,
+	defaultSeverity: "error",
+	dependencies: {
+		scope: "entry",
+		schemas: true
+	},
+	visitor
+};
+
+//#endregion
+export { emptyRequiredValueRule };
+//# sourceMappingURL=empty-required-value.js.map

package/dist/checker/rules/empty-required-value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty-required-value.js","names":["category: RuleCategory","visitor: RuleVisitor","emptyRequiredValueRule: Rule"],"sources":["../../../src/checker/rules/empty-required-value.ts"],"sourcesContent":["import type { Rule, RuleCategory } from \"../rules/rules.js\";\nimport type { RuleVisitor } from \"../visitor.js\";\n\nconst category: RuleCategory = \"metadata\";\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      const fieldSchema = schema.fields.get(fieldName);\n\n      if (!fieldSchema) {\n        continue; // Will be caught by unknown-field rule\n      }\n\n      // Check if the field is required and has an empty value\n      if (!fieldSchema.optional && fieldSchema.defaultValue === null) {\n        const rawValue = meta.value.raw.trim();\n        // Check for empty or effectively empty values\n        if (rawValue === \"\" || rawValue === '\"\"') {\n          ctx.report({\n            message: `Required field '${fieldName}' has an empty value.`,\n            file: ctx.file,\n            location: meta.value.location,\n            sourceMap: ctx.sourceMap,\n            data: { fieldName, entity },\n          });\n        }\n      }\n    }\n  },\n};\n\n/**\n * Check for required fields that are present but have empty values\n */\nexport const emptyRequiredValueRule: Rule = {\n  code: \"empty-required-value\",\n  name: \"Empty Required Value\",\n  description: \"Required field has empty value\",\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;CAC5B,MAAM,SAAS,SAAS,IAAI,OAAO;AAEnC,KAAI,CAAC,OACH;AAGF,MAAK,MAAM,QAAQ,MAAM,UAAU;EACjC,MAAM,YAAY,KAAK,IAAI;EAC3B,MAAM,cAAc,OAAO,OAAO,IAAI,UAAU;AAEhD,MAAI,CAAC,YACH;AAIF,MAAI,CAAC,YAAY,YAAY,YAAY,iBAAiB,MAAM;GAC9D,MAAM,WAAW,KAAK,MAAM,IAAI,MAAM;AAEtC,OAAI,aAAa,MAAM,aAAa,OAClC,KAAI,OAAO;IACT,SAAS,mBAAmB,UAAU;IACtC,MAAM,IAAI;IACV,UAAU,KAAK,MAAM;IACrB,WAAW,IAAI;IACf,MAAM;KAAE;KAAW;KAAQ;IAC5B,CAAC;;;GAKX;;;;AAKD,MAAaC,yBAA+B;CAC1C,MAAM;CACN,MAAM;CACN,aAAa;CACb;CACA,iBAAiB;CACjB,cAAc;EAAE,OAAO;EAAS,SAAS;EAAM;CAC/C;CACD"}