@dxos/datalog 0.0.1 → 0.13.0

package/dist/lib/chunk-Checker.mjs

@@ -0,0 +1,414 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { formatRule, variablesOf } from "./Ast.mjs";
+import { acceptsBinding } from "./Builtin.mjs";
+import { BaseError } from "@dxos/errors";
+//#region src/internal/plan.ts
+/** Assigns a slot per named variable of a rule. */
+var Slots = class {
+	#slots = /* @__PURE__ */ new Map();
+	get size() {
+		return this.#slots.size;
+	}
+	slot(name) {
+		let slot = this.#slots.get(name);
+		if (slot === void 0) {
+			slot = this.#slots.size;
+			this.#slots.set(name, slot);
+		}
+		return slot;
+	}
+	ref(term) {
+		if (term.type === "constant") return {
+			kind: "const",
+			value: term.value
+		};
+		return term.anonymous ? { kind: "wild" } : {
+			kind: "slot",
+			slot: this.slot(term.name)
+		};
+	}
+};
+var isBound = (term, bound) => term.type === "constant" || !term.anonymous && bound.has(term.name);
+var unboundNames = (terms, bound) => terms.flatMap((term) => term.type === "variable" && !term.anonymous && !bound.has(term.name) ? [term.name] : []);
+var variableNames = (literal) => {
+	switch (literal.type) {
+		case "atom": return literal.atom.terms.flatMap((term) => term.type === "variable" && !term.anonymous ? [term.name] : []);
+		case "comparison": return [literal.left, literal.right].flatMap((term) => term.type === "variable" && !term.anonymous ? [term.name] : []);
+		case "aggregate": return [...[literal.result, ...literal.target ? [literal.target] : []].flatMap((term) => term.type === "variable" && !term.anonymous ? [term.name] : []), ...literal.body.flatMap(variableNames)];
+	}
+};
+/**
+* Orders a rule body so every literal runs once its inputs are bound: filters as early as
+* possible, then the relation scan with the most bound columns, then generating built-ins.
+* @param outer Variables used outside the body (the head, or the enclosing rule of an aggregate).
+* @param first Literal to scan first (the semi-naive delta).
+*/
+var planBody = (options) => {
+	const { body, builtins, slots, outer, first } = options;
+	const bound = new Set(options.bound ?? []);
+	const steps = [];
+	const remaining = new Set(body.keys());
+	const unresolved = [];
+	const scan = (index, literal) => {
+		const boundColumns = [];
+		const binds = [];
+		literal.atom.terms.forEach((term, column) => {
+			if (isBound(term, bound)) boundColumns.push({
+				column,
+				ref: slots.ref(term)
+			});
+			else if (term.type === "variable" && !term.anonymous) binds.push({
+				column,
+				slot: slots.slot(term.name)
+			});
+		});
+		for (const name of unboundNames(literal.atom.terms, bound)) bound.add(name);
+		steps.push({
+			kind: "scan",
+			literal: index,
+			relation: literal.atom.predicate,
+			bound: boundColumns,
+			binds
+		});
+	};
+	/** Variables any other literal or the outer scope uses, which an aggregate must correlate on. */
+	const correlated = (index, literal) => {
+		const elsewhere = /* @__PURE__ */ new Set([...outer, ...body.flatMap((other, at) => at === index ? [] : variableNames(other))]);
+		return [...new Set(literal.body.flatMap(variableNames))].filter((name) => elsewhere.has(name));
+	};
+	/** Schedules `index` if it is a filter (or, with `generate`, a generator) whose inputs are bound. */
+	const trySchedule = (index, generate) => {
+		const literal = body[index];
+		switch (literal.type) {
+			case "atom": {
+				const builtin = builtins.get(literal.atom.predicate);
+				if (!builtin) {
+					if (!literal.negated) return false;
+					if (unboundNames(literal.atom.terms, bound).length > 0) return false;
+					steps.push({
+						kind: "negation",
+						relation: literal.atom.predicate,
+						bound: literal.atom.terms.flatMap((term, column) => term.type === "variable" && term.anonymous ? [] : [{
+							column,
+							ref: slots.ref(term)
+						}])
+					});
+					return true;
+				}
+				const boundArgs = literal.atom.terms.map((term) => isBound(term, bound));
+				if (!boundArgs.every(Boolean) && (!generate || literal.negated || !acceptsBinding(builtin, boundArgs))) return false;
+				steps.push({
+					kind: "builtin",
+					builtin,
+					args: literal.atom.terms.map((term) => slots.ref(term)),
+					free: boundArgs.map((value) => !value),
+					negated: literal.negated
+				});
+				for (const name of unboundNames(literal.atom.terms, bound)) bound.add(name);
+				return true;
+			}
+			case "comparison": {
+				const left = isBound(literal.left, bound);
+				const right = isBound(literal.right, bound);
+				if (left && right) {
+					steps.push({
+						kind: "compare",
+						operator: literal.operator,
+						left: slots.ref(literal.left),
+						right: slots.ref(literal.right)
+					});
+					return true;
+				}
+				if (!generate || literal.operator !== "=" || left === right) return false;
+				const [target, source] = left ? [literal.right, literal.left] : [literal.left, literal.right];
+				if (target.type !== "variable" || target.anonymous) return false;
+				steps.push({
+					kind: "compare",
+					operator: "=",
+					left: slots.ref(literal.left),
+					right: slots.ref(literal.right),
+					assign: {
+						slot: slots.slot(target.name),
+						from: slots.ref(source)
+					}
+				});
+				bound.add(target.name);
+				return true;
+			}
+			case "aggregate": {
+				const correlation = correlated(index, literal);
+				if (correlation.some((name) => !bound.has(name))) return false;
+				const resultBound = isBound(literal.result, bound);
+				if (!resultBound && !generate) return false;
+				const inner = planBody({
+					body: literal.body,
+					builtins,
+					slots,
+					outer: new Set(correlation),
+					bound: new Set(correlation)
+				});
+				if (inner.unresolved.length > 0) {
+					unresolved.push(...inner.unresolved.map(({ reason }) => ({
+						literal: index,
+						reason
+					})));
+					return true;
+				}
+				if (literal.target && !isBound(literal.target, inner.bound)) {
+					unresolved.push({
+						literal: index,
+						reason: `aggregate target is not bound by the aggregate body`
+					});
+					return true;
+				}
+				const local = [...inner.bound].filter((name) => !correlation.includes(name)).map((name) => slots.slot(name));
+				steps.push({
+					kind: "aggregate",
+					function: literal.function,
+					steps: inner.steps,
+					local,
+					target: literal.target ? slots.ref(literal.target) : void 0,
+					result: slots.ref(literal.result),
+					assignResult: !resultBound
+				});
+				if (literal.result.type === "variable" && !literal.result.anonymous) bound.add(literal.result.name);
+				return true;
+			}
+		}
+	};
+	if (first !== void 0) {
+		const literal = body[first];
+		if (literal.type === "atom" && !literal.negated && !builtins.has(literal.atom.predicate)) {
+			remaining.delete(first);
+			scan(first, literal);
+		}
+	}
+	while (remaining.size > 0) {
+		let progressed = false;
+		for (const index of remaining) if (trySchedule(index, false)) {
+			remaining.delete(index);
+			progressed = true;
+		}
+		if (progressed) continue;
+		let best;
+		let bestBound = -1;
+		for (const index of remaining) {
+			const literal = body[index];
+			if (literal.type === "atom" && !literal.negated && !builtins.has(literal.atom.predicate)) {
+				const boundCount = literal.atom.terms.filter((term) => isBound(term, bound)).length;
+				if (boundCount > bestBound) {
+					best = index;
+					bestBound = boundCount;
+				}
+			}
+		}
+		if (best !== void 0) {
+			const literal = body[best];
+			if (literal.type === "atom") {
+				remaining.delete(best);
+				scan(best, literal);
+			}
+			continue;
+		}
+		for (const index of remaining) if (trySchedule(index, true)) {
+			remaining.delete(index);
+			progressed = true;
+			break;
+		}
+		if (!progressed) break;
+	}
+	for (const index of remaining) unresolved.push({
+		literal: index,
+		reason: describeUnresolved(body[index], bound, builtins)
+	});
+	return {
+		steps,
+		unresolved,
+		bound
+	};
+};
+var describeUnresolved = (literal, bound, builtins) => {
+	switch (literal.type) {
+		case "atom": {
+			const names = unboundNames(literal.atom.terms, bound).join(", ");
+			if (builtins.has(literal.atom.predicate)) return literal.negated ? `negated built-in ${literal.atom.predicate} needs every argument bound (${names} unbound)` : `no binding mode of built-in ${literal.atom.predicate}/${literal.atom.terms.length} accepts ${names} unbound`;
+			return `variable ${names} under negation is not bound by a positive literal`;
+		}
+		case "comparison": return `variable ${unboundNames([literal.left, literal.right], bound).join(", ")} in comparison is not bound`;
+		case "aggregate": return `aggregate depends on unbound variables`;
+	}
+};
+//#endregion
+//#region src/internal/stratify.ts
+/** Relations a literal reads; negation and aggregation read them non-monotonically. */
+var dependencies = (literal, builtins) => {
+	switch (literal.type) {
+		case "atom": return builtins.has(literal.atom.predicate) ? [] : [{
+			predicate: literal.atom.predicate,
+			negative: literal.negated
+		}];
+		case "comparison": return [];
+		case "aggregate": return literal.body.flatMap((inner) => dependencies(inner, builtins).map(({ predicate }) => ({
+			predicate,
+			negative: true
+		})));
+	}
+};
+/**
+* Splits rules into strata: one per strongly connected component of the predicate graph, in
+* dependency order; fails when negation or aggregation occurs inside a component.
+*/
+var stratify = (rules, builtins) => {
+	const defined = new Set(rules.filter((rule) => rule.body.length > 0).map((rule) => rule.head.predicate));
+	const edges = /* @__PURE__ */ new Map();
+	for (const predicate of defined) edges.set(predicate, []);
+	for (const rule of rules) for (const literal of rule.body) for (const dependency of dependencies(literal, builtins)) if (defined.has(dependency.predicate)) edges.get(rule.head.predicate)?.push(dependency);
+	const components = [];
+	const index = /* @__PURE__ */ new Map();
+	const lowLink = /* @__PURE__ */ new Map();
+	const stack = [];
+	const onStack = /* @__PURE__ */ new Set();
+	const visit = (predicate) => {
+		index.set(predicate, index.size);
+		lowLink.set(predicate, index.get(predicate) ?? 0);
+		stack.push(predicate);
+		onStack.add(predicate);
+		for (const { predicate: next } of edges.get(predicate) ?? []) if (!index.has(next)) {
+			visit(next);
+			lowLink.set(predicate, Math.min(lowLink.get(predicate) ?? 0, lowLink.get(next) ?? 0));
+		} else if (onStack.has(next)) lowLink.set(predicate, Math.min(lowLink.get(predicate) ?? 0, index.get(next) ?? 0));
+		if (lowLink.get(predicate) === index.get(predicate)) {
+			const component = [];
+			let member;
+			do {
+				member = stack.pop();
+				if (member !== void 0) {
+					onStack.delete(member);
+					component.push(member);
+				}
+			} while (member !== void 0 && member !== predicate);
+			components.push(component);
+		}
+	};
+	for (const predicate of defined) if (!index.has(predicate)) visit(predicate);
+	const cycles = [];
+	const strata = components.map((component) => {
+		const members = new Set(component);
+		const internal = component.flatMap((predicate) => (edges.get(predicate) ?? []).filter((dependency) => members.has(dependency.predicate)));
+		if (internal.some((dependency) => dependency.negative)) cycles.push(component.sort());
+		return {
+			predicates: members,
+			rules: rules.flatMap((rule, ruleIndex) => rule.body.length > 0 && members.has(rule.head.predicate) ? [ruleIndex] : []),
+			recursive: internal.length > 0
+		};
+	});
+	return cycles.length > 0 ? {
+		ok: false,
+		cycles
+	} : {
+		ok: true,
+		strata
+	};
+};
+//#endregion
+//#region src/Checker.ts
+var Checker_exports = /* @__PURE__ */ __exportAll({
+	CheckError: () => CheckError,
+	check: () => check,
+	formatDiagnostic: () => formatDiagnostic
+});
+/** Thrown when a program with diagnostics is evaluated. */
+var CheckError = class extends BaseError.extend("CheckError", "Invalid program") {
+	diagnostics;
+	constructor(diagnostics) {
+		super({ message: `Invalid program:\n${diagnostics.map(formatDiagnostic).join("\n")}` });
+		this.diagnostics = diagnostics;
+	}
+};
+/** Formats a diagnostic as `line:column code: message`. */
+var formatDiagnostic = (diagnostic) => {
+	return `${diagnostic.position ? `${diagnostic.position.line}:${diagnostic.position.column} ` : ""}${diagnostic.code}: ${diagnostic.message}`;
+};
+/**
+* Checks arity consistency, built-in heads, undefined predicates, range restriction (safety) and
+* stratification; an empty result means the program can be evaluated.
+*/
+var check = (program, options = {}) => {
+	const builtins = options.builtins ?? /* @__PURE__ */ new Map();
+	const diagnostics = [];
+	const arities = /* @__PURE__ */ new Map();
+	for (const builtin of builtins.values()) arities.set(builtin.name, builtin.arity);
+	for (const [name, arity] of Object.entries(options.relations ?? {})) arities.set(name, arity);
+	const defined = new Set(program.rules.map((rule) => rule.head.predicate));
+	const visitAtom = (atom, rule, position) => {
+		const expected = arities.get(atom.predicate);
+		if (expected === void 0) arities.set(atom.predicate, atom.terms.length);
+		else if (expected !== atom.terms.length) diagnostics.push({
+			code: "arity",
+			message: `${atom.predicate}/${atom.terms.length} used where ${atom.predicate}/${expected} is expected`,
+			rule,
+			position
+		});
+	};
+	const visitLiteral = (literal, rule, fallback) => {
+		const position = literal.position ?? fallback;
+		if (literal.type === "atom") {
+			visitAtom(literal.atom, rule, position);
+			const predicate = literal.atom.predicate;
+			if (options.relations && !defined.has(predicate) && !builtins.has(predicate) && !(predicate in options.relations)) diagnostics.push({
+				code: "undefined",
+				message: `${predicate}/${literal.atom.terms.length} is not a relation, rule or built-in`,
+				rule,
+				position
+			});
+		} else if (literal.type === "aggregate") literal.body.forEach((inner) => visitLiteral(inner, rule, position));
+	};
+	program.rules.forEach((rule, index) => {
+		if (builtins.has(rule.head.predicate)) diagnostics.push({
+			code: "builtin-head",
+			message: `rule defines built-in ${rule.head.predicate}`,
+			rule: index,
+			position: rule.position
+		});
+		visitAtom(rule.head, index, rule.position);
+		rule.body.forEach((literal) => visitLiteral(literal, index, rule.position));
+		const head = new Set(variablesOf(rule.head.terms));
+		const plan = planBody({
+			body: rule.body,
+			builtins,
+			slots: new Slots(),
+			outer: head
+		});
+		for (const { literal, reason } of plan.unresolved) diagnostics.push({
+			code: "unsafe",
+			message: `${reason} in: ${formatRule(rule)}`,
+			rule: index,
+			position: rule.body[literal].position ?? rule.position
+		});
+		const unboundHead = [...head].filter((name) => !plan.bound.has(name));
+		if (unboundHead.length > 0) diagnostics.push({
+			code: "unsafe",
+			message: `head variable ${unboundHead.join(", ")} is not bound by the body in: ${formatRule(rule)}`,
+			rule: index,
+			position: rule.position
+		});
+		if (rule.head.terms.some((term) => term.type === "variable" && term.anonymous)) diagnostics.push({
+			code: "unsafe",
+			message: `anonymous variable in head of: ${formatRule(rule)}`,
+			rule: index,
+			position: rule.position
+		});
+	});
+	const stratification = stratify(program.rules, builtins);
+	if (!stratification.ok) for (const cycle of stratification.cycles) diagnostics.push({
+		code: "unstratifiable",
+		message: `negation or aggregation through recursion among: ${cycle.join(", ")}`,
+		rule: program.rules.findIndex((rule) => cycle.includes(rule.head.predicate)),
+		position: program.rules.find((rule) => cycle.includes(rule.head.predicate))?.position
+	});
+	return diagnostics;
+};
+//#endregion
+export { dependencies as a, planBody as c, formatDiagnostic as i, Checker_exports as n, stratify as o, check as r, Slots as s, CheckError as t };
+
+//# sourceMappingURL=chunk-Checker.mjs.map

package/dist/lib/chunk-Checker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-Checker.mjs","names":[],"sources":["../../src/internal/plan.ts","../../src/internal/stratify.ts","../../src/Checker.ts"],"sourcesContent":["//\n// Copyright 2026 DXOS.org\n//\n\nimport type * as Ast from '../Ast.ts';\nimport * as Builtin from '../Builtin.ts';\n\n/** A term resolved against a rule's variable slots; `wild` is an anonymous variable. */\nexport type Ref =\n  | { readonly kind: 'const'; readonly value: Ast.Value }\n  | { readonly kind: 'slot'; readonly slot: number }\n  | { readonly kind: 'wild' };\n\nexport type ScanStep = {\n  readonly kind: 'scan';\n  readonly literal: number;\n  readonly relation: string;\n  /** Columns whose value is known before the scan, with the value source. */\n  readonly bound: ReadonlyArray<{ readonly column: number; readonly ref: Ref }>;\n  /** Columns that bind a slot, or check it when the variable repeats within the atom. */\n  readonly binds: ReadonlyArray<{ readonly column: number; readonly slot: number }>;\n};\n\nexport type NegationStep = {\n  readonly kind: 'negation';\n  readonly relation: string;\n  readonly bound: ReadonlyArray<{ readonly column: number; readonly ref: Ref }>;\n};\n\nexport type CompareStep = {\n  readonly kind: 'compare';\n  readonly operator: Ast.ComparisonOperator;\n  readonly left: Ref;\n  readonly right: Ref;\n  /** Set for `X = term` with `X` unbound: assigns instead of comparing. */\n  readonly assign?: { readonly slot: number; readonly from: Ref };\n};\n\nexport type BuiltinStep = {\n  readonly kind: 'builtin';\n  readonly builtin: Builtin.Builtin;\n  readonly args: ReadonlyArray<Ref>;\n  /** Arguments unbound at call time, passed as `undefined` and bound from the results. */\n  readonly free: ReadonlyArray<boolean>;\n  readonly negated: boolean;\n};\n\nexport type AggregateStep = {\n  readonly kind: 'aggregate';\n  readonly function: Ast.AggregateFunction;\n  readonly steps: ReadonlyArray<Step>;\n  /** Slots local to the aggregate body; distinct assignments of these are aggregated. */\n  readonly local: ReadonlyArray<number>;\n  readonly target?: Ref;\n  readonly result: Ref;\n  readonly assignResult: boolean;\n};\n\nexport type Step = ScanStep | NegationStep | CompareStep | BuiltinStep | AggregateStep;\n\nexport type Unresolved = { readonly literal: number; readonly reason: string };\n\nexport type Plan = {\n  readonly steps: ReadonlyArray<Step>;\n  readonly unresolved: ReadonlyArray<Unresolved>;\n  readonly bound: ReadonlySet<string>;\n};\n\n/** Assigns a slot per named variable of a rule. */\nexport class Slots {\n  readonly #slots = new Map<string, number>();\n\n  get size(): number {\n    return this.#slots.size;\n  }\n\n  slot(name: string): number {\n    let slot = this.#slots.get(name);\n    if (slot === undefined) {\n      slot = this.#slots.size;\n      this.#slots.set(name, slot);\n    }\n    return slot;\n  }\n\n  ref(term: Ast.Term): Ref {\n    if (term.type === 'constant') {\n      return { kind: 'const', value: term.value };\n    }\n    return term.anonymous ? { kind: 'wild' } : { kind: 'slot', slot: this.slot(term.name) };\n  }\n}\n\nconst isBound = (term: Ast.Term, bound: ReadonlySet<string>) =>\n  term.type === 'constant' || (!term.anonymous && bound.has(term.name));\n\nconst unboundNames = (terms: ReadonlyArray<Ast.Term>, bound: ReadonlySet<string>) =>\n  terms.flatMap((term) => (term.type === 'variable' && !term.anonymous && !bound.has(term.name) ? [term.name] : []));\n\nconst variableNames = (literal: Ast.Literal): string[] => {\n  switch (literal.type) {\n    case 'atom':\n      return literal.atom.terms.flatMap((term) => (term.type === 'variable' && !term.anonymous ? [term.name] : []));\n    case 'comparison':\n      return [literal.left, literal.right].flatMap((term) =>\n        term.type === 'variable' && !term.anonymous ? [term.name] : [],\n      );\n    case 'aggregate':\n      return [\n        ...[literal.result, ...(literal.target ? [literal.target] : [])].flatMap((term) =>\n          term.type === 'variable' && !term.anonymous ? [term.name] : [],\n        ),\n        ...literal.body.flatMap(variableNames),\n      ];\n  }\n};\n\n/**\n * Orders a rule body so every literal runs once its inputs are bound: filters as early as\n * possible, then the relation scan with the most bound columns, then generating built-ins.\n * @param outer Variables used outside the body (the head, or the enclosing rule of an aggregate).\n * @param first Literal to scan first (the semi-naive delta).\n */\nexport const planBody = (options: {\n  body: ReadonlyArray<Ast.Literal>;\n  builtins: Builtin.Registry;\n  slots: Slots;\n  outer: ReadonlySet<string>;\n  bound?: ReadonlySet<string>;\n  first?: number;\n}): Plan => {\n  const { body, builtins, slots, outer, first } = options;\n  const bound = new Set(options.bound ?? []);\n  const steps: Step[] = [];\n  const remaining = new Set(body.keys());\n  const unresolved: Unresolved[] = [];\n\n  const scan = (index: number, literal: Ast.AtomLiteral) => {\n    const boundColumns: { column: number; ref: Ref }[] = [];\n    const binds: { column: number; slot: number }[] = [];\n    literal.atom.terms.forEach((term, column) => {\n      if (isBound(term, bound)) {\n        boundColumns.push({ column, ref: slots.ref(term) });\n      } else if (term.type === 'variable' && !term.anonymous) {\n        binds.push({ column, slot: slots.slot(term.name) });\n      }\n    });\n    for (const name of unboundNames(literal.atom.terms, bound)) {\n      bound.add(name);\n    }\n    steps.push({ kind: 'scan', literal: index, relation: literal.atom.predicate, bound: boundColumns, binds });\n  };\n\n  /** Variables any other literal or the outer scope uses, which an aggregate must correlate on. */\n  const correlated = (index: number, literal: Ast.AggregateLiteral): string[] => {\n    const elsewhere = new Set([...outer, ...body.flatMap((other, at) => (at === index ? [] : variableNames(other)))]);\n    const inner = new Set(literal.body.flatMap(variableNames));\n    return [...inner].filter((name) => elsewhere.has(name));\n  };\n\n  /** Schedules `index` if it is a filter (or, with `generate`, a generator) whose inputs are bound. */\n  const trySchedule = (index: number, generate: boolean): boolean => {\n    const literal = body[index];\n    switch (literal.type) {\n      case 'atom': {\n        const builtin = builtins.get(literal.atom.predicate);\n        if (!builtin) {\n          if (!literal.negated) {\n            return false;\n          }\n          if (unboundNames(literal.atom.terms, bound).length > 0) {\n            return false;\n          }\n          steps.push({\n            kind: 'negation',\n            relation: literal.atom.predicate,\n            bound: literal.atom.terms.flatMap((term, column) =>\n              term.type === 'variable' && term.anonymous ? [] : [{ column, ref: slots.ref(term) }],\n            ),\n          });\n          return true;\n        }\n        const boundArgs = literal.atom.terms.map((term) => isBound(term, bound));\n        const allBound = boundArgs.every(Boolean);\n        if (!allBound && (!generate || literal.negated || !Builtin.acceptsBinding(builtin, boundArgs))) {\n          return false;\n        }\n        steps.push({\n          kind: 'builtin',\n          builtin,\n          args: literal.atom.terms.map((term) => slots.ref(term)),\n          free: boundArgs.map((value) => !value),\n          negated: literal.negated,\n        });\n        for (const name of unboundNames(literal.atom.terms, bound)) {\n          bound.add(name);\n        }\n        return true;\n      }\n      case 'comparison': {\n        const left = isBound(literal.left, bound);\n        const right = isBound(literal.right, bound);\n        if (left && right) {\n          steps.push({\n            kind: 'compare',\n            operator: literal.operator,\n            left: slots.ref(literal.left),\n            right: slots.ref(literal.right),\n          });\n          return true;\n        }\n        if (!generate || literal.operator !== '=' || left === right) {\n          return false;\n        }\n        const [target, source] = left ? [literal.right, literal.left] : [literal.left, literal.right];\n        if (target.type !== 'variable' || target.anonymous) {\n          return false;\n        }\n        steps.push({\n          kind: 'compare',\n          operator: '=',\n          left: slots.ref(literal.left),\n          right: slots.ref(literal.right),\n          assign: { slot: slots.slot(target.name), from: slots.ref(source) },\n        });\n        bound.add(target.name);\n        return true;\n      }\n      case 'aggregate': {\n        const correlation = correlated(index, literal);\n        if (correlation.some((name) => !bound.has(name))) {\n          return false;\n        }\n        const resultBound = isBound(literal.result, bound);\n        if (!resultBound && !generate) {\n          return false;\n        }\n        const inner = planBody({\n          body: literal.body,\n          builtins,\n          slots,\n          outer: new Set(correlation),\n          bound: new Set(correlation),\n        });\n        if (inner.unresolved.length > 0) {\n          unresolved.push(...inner.unresolved.map(({ reason }) => ({ literal: index, reason })));\n          return true;\n        }\n        if (literal.target && !isBound(literal.target, inner.bound)) {\n          unresolved.push({ literal: index, reason: `aggregate target is not bound by the aggregate body` });\n          return true;\n        }\n        const local = [...inner.bound].filter((name) => !correlation.includes(name)).map((name) => slots.slot(name));\n        steps.push({\n          kind: 'aggregate',\n          function: literal.function,\n          steps: inner.steps,\n          local,\n          target: literal.target ? slots.ref(literal.target) : undefined,\n          result: slots.ref(literal.result),\n          assignResult: !resultBound,\n        });\n        if (literal.result.type === 'variable' && !literal.result.anonymous) {\n          bound.add(literal.result.name);\n        }\n        return true;\n      }\n    }\n  };\n\n  if (first !== undefined) {\n    const literal = body[first];\n    if (literal.type === 'atom' && !literal.negated && !builtins.has(literal.atom.predicate)) {\n      remaining.delete(first);\n      scan(first, literal);\n    }\n  }\n\n  while (remaining.size > 0) {\n    let progressed = false;\n    for (const index of remaining) {\n      if (trySchedule(index, false)) {\n        remaining.delete(index);\n        progressed = true;\n      }\n    }\n    if (progressed) {\n      continue;\n    }\n\n    let best: number | undefined;\n    let bestBound = -1;\n    for (const index of remaining) {\n      const literal = body[index];\n      if (literal.type === 'atom' && !literal.negated && !builtins.has(literal.atom.predicate)) {\n        const boundCount = literal.atom.terms.filter((term) => isBound(term, bound)).length;\n        if (boundCount > bestBound) {\n          best = index;\n          bestBound = boundCount;\n        }\n      }\n    }\n    if (best !== undefined) {\n      const literal = body[best];\n      if (literal.type === 'atom') {\n        remaining.delete(best);\n        scan(best, literal);\n      }\n      continue;\n    }\n\n    for (const index of remaining) {\n      if (trySchedule(index, true)) {\n        remaining.delete(index);\n        progressed = true;\n        break;\n      }\n    }\n    if (!progressed) {\n      break;\n    }\n  }\n\n  for (const index of remaining) {\n    unresolved.push({ literal: index, reason: describeUnresolved(body[index], bound, builtins) });\n  }\n  return { steps, unresolved, bound };\n};\n\nconst describeUnresolved = (literal: Ast.Literal, bound: ReadonlySet<string>, builtins: Builtin.Registry): string => {\n  switch (literal.type) {\n    case 'atom': {\n      const names = unboundNames(literal.atom.terms, bound).join(', ');\n      if (builtins.has(literal.atom.predicate)) {\n        return literal.negated\n          ? `negated built-in ${literal.atom.predicate} needs every argument bound (${names} unbound)`\n          : `no binding mode of built-in ${literal.atom.predicate}/${literal.atom.terms.length} accepts ${names} unbound`;\n      }\n      return `variable ${names} under negation is not bound by a positive literal`;\n    }\n    case 'comparison':\n      return `variable ${unboundNames([literal.left, literal.right], bound).join(', ')} in comparison is not bound`;\n    case 'aggregate':\n      return `aggregate depends on unbound variables`;\n  }\n};\n","//\n// Copyright 2026 DXOS.org\n//\n\nimport type * as Ast from '../Ast.ts';\nimport type * as Builtin from '../Builtin.ts';\n\nexport type Dependency = { readonly predicate: string; readonly negative: boolean };\n\nexport type Stratum = {\n  /** Predicates defined by the stratum's rules (one strongly connected component). */\n  readonly predicates: ReadonlySet<string>;\n  /** Indexes into the program's rules. */\n  readonly rules: ReadonlyArray<number>;\n  readonly recursive: boolean;\n};\n\nexport type Stratification =\n  | { readonly ok: true; readonly strata: ReadonlyArray<Stratum> }\n  | { readonly ok: false; readonly cycles: ReadonlyArray<ReadonlyArray<string>> };\n\n/** Relations a literal reads; negation and aggregation read them non-monotonically. */\nexport const dependencies = (literal: Ast.Literal, builtins: Builtin.Registry): Dependency[] => {\n  switch (literal.type) {\n    case 'atom':\n      return builtins.has(literal.atom.predicate)\n        ? []\n        : [{ predicate: literal.atom.predicate, negative: literal.negated }];\n    case 'comparison':\n      return [];\n    case 'aggregate':\n      return literal.body.flatMap((inner) =>\n        dependencies(inner, builtins).map(({ predicate }) => ({ predicate, negative: true })),\n      );\n  }\n};\n\n/**\n * Splits rules into strata: one per strongly connected component of the predicate graph, in\n * dependency order; fails when negation or aggregation occurs inside a component.\n */\nexport const stratify = (rules: ReadonlyArray<Ast.Rule>, builtins: Builtin.Registry): Stratification => {\n  const defined = new Set(rules.filter((rule) => rule.body.length > 0).map((rule) => rule.head.predicate));\n  const edges = new Map<string, Dependency[]>();\n  for (const predicate of defined) {\n    edges.set(predicate, []);\n  }\n  for (const rule of rules) {\n    for (const literal of rule.body) {\n      for (const dependency of dependencies(literal, builtins)) {\n        if (defined.has(dependency.predicate)) {\n          edges.get(rule.head.predicate)?.push(dependency);\n        }\n      }\n    }\n  }\n\n  // Tarjan's algorithm emits each component after every component it depends on.\n  const components: string[][] = [];\n  const index = new Map<string, number>();\n  const lowLink = new Map<string, number>();\n  const stack: string[] = [];\n  const onStack = new Set<string>();\n  const visit = (predicate: string) => {\n    index.set(predicate, index.size);\n    lowLink.set(predicate, index.get(predicate) ?? 0);\n    stack.push(predicate);\n    onStack.add(predicate);\n    for (const { predicate: next } of edges.get(predicate) ?? []) {\n      if (!index.has(next)) {\n        visit(next);\n        lowLink.set(predicate, Math.min(lowLink.get(predicate) ?? 0, lowLink.get(next) ?? 0));\n      } else if (onStack.has(next)) {\n        lowLink.set(predicate, Math.min(lowLink.get(predicate) ?? 0, index.get(next) ?? 0));\n      }\n    }\n    if (lowLink.get(predicate) === index.get(predicate)) {\n      const component: string[] = [];\n      let member: string | undefined;\n      do {\n        member = stack.pop();\n        if (member !== undefined) {\n          onStack.delete(member);\n          component.push(member);\n        }\n      } while (member !== undefined && member !== predicate);\n      components.push(component);\n    }\n  };\n  for (const predicate of defined) {\n    if (!index.has(predicate)) {\n      visit(predicate);\n    }\n  }\n\n  const cycles: string[][] = [];\n  const strata: Stratum[] = components.map((component) => {\n    const members = new Set(component);\n    const internal = component.flatMap((predicate) =>\n      (edges.get(predicate) ?? []).filter((dependency) => members.has(dependency.predicate)),\n    );\n    if (internal.some((dependency) => dependency.negative)) {\n      cycles.push(component.sort());\n    }\n    return {\n      predicates: members,\n      rules: rules.flatMap((rule, ruleIndex) =>\n        rule.body.length > 0 && members.has(rule.head.predicate) ? [ruleIndex] : [],\n      ),\n      recursive: internal.length > 0,\n    };\n  });\n  return cycles.length > 0 ? { ok: false, cycles } : { ok: true, strata };\n};\n","//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\nimport { BaseError } from '@dxos/errors';\n\nimport * as Ast from './Ast.ts';\nimport type * as Builtin from './Builtin.ts';\nimport { Slots, planBody } from './internal/plan.ts';\nimport { stratify } from './internal/stratify.ts';\n\nexport type DiagnosticCode = 'arity' | 'builtin-head' | 'undefined' | 'unsafe' | 'unstratifiable';\n\n/** A static error in a program. */\nexport type Diagnostic = {\n  readonly code: DiagnosticCode;\n  readonly message: string;\n  /** Index of the offending rule. */\n  readonly rule?: number;\n  readonly position?: Ast.Position;\n};\n\nexport type Options = {\n  readonly builtins?: Builtin.Registry;\n  /**\n   * Base relations and their arities. When given, a body predicate that is neither defined by a\n   * rule, declared here nor a built-in is reported as `undefined`.\n   */\n  readonly relations?: Readonly<Record<string, number>>;\n};\n\n/** Thrown when a program with diagnostics is evaluated. */\nexport class CheckError extends BaseError.extend('CheckError', 'Invalid program') {\n  // A typed field rather than `context`, which would repeat every diagnostic in the message as JSON.\n  readonly diagnostics: ReadonlyArray<Diagnostic>;\n\n  constructor(diagnostics: ReadonlyArray<Diagnostic>) {\n    super({ message: `Invalid program:\\n${diagnostics.map(formatDiagnostic).join('\\n')}` });\n    this.diagnostics = diagnostics;\n  }\n}\n\n/** Formats a diagnostic as `line:column code: message`. */\nexport const formatDiagnostic = (diagnostic: Diagnostic): string => {\n  const at = diagnostic.position ? `${diagnostic.position.line}:${diagnostic.position.column} ` : '';\n  return `${at}${diagnostic.code}: ${diagnostic.message}`;\n};\n\n/**\n * Checks arity consistency, built-in heads, undefined predicates, range restriction (safety) and\n * stratification; an empty result means the program can be evaluated.\n */\nexport const check = (program: Ast.Program, options: Options = {}): Diagnostic[] => {\n  const builtins = options.builtins ?? new Map();\n  const diagnostics: Diagnostic[] = [];\n  const arities = new Map<string, number>();\n  for (const builtin of builtins.values()) {\n    arities.set(builtin.name, builtin.arity);\n  }\n  for (const [name, arity] of Object.entries(options.relations ?? {})) {\n    arities.set(name, arity);\n  }\n  const defined = new Set(program.rules.map((rule) => rule.head.predicate));\n\n  const visitAtom = (atom: Ast.Atom, rule: number, position: Ast.Position | undefined) => {\n    const expected = arities.get(atom.predicate);\n    if (expected === undefined) {\n      arities.set(atom.predicate, atom.terms.length);\n    } else if (expected !== atom.terms.length) {\n      diagnostics.push({\n        code: 'arity',\n        message: `${atom.predicate}/${atom.terms.length} used where ${atom.predicate}/${expected} is expected`,\n        rule,\n        position,\n      });\n    }\n  };\n  const visitLiteral = (literal: Ast.Literal, rule: number, fallback: Ast.Position | undefined) => {\n    const position = literal.position ?? fallback;\n    if (literal.type === 'atom') {\n      visitAtom(literal.atom, rule, position);\n      const predicate = literal.atom.predicate;\n      if (\n        options.relations &&\n        !defined.has(predicate) &&\n        !builtins.has(predicate) &&\n        !(predicate in options.relations)\n      ) {\n        diagnostics.push({\n          code: 'undefined',\n          message: `${predicate}/${literal.atom.terms.length} is not a relation, rule or built-in`,\n          rule,\n          position,\n        });\n      }\n    } else if (literal.type === 'aggregate') {\n      literal.body.forEach((inner) => visitLiteral(inner, rule, position));\n    }\n  };\n\n  program.rules.forEach((rule, index) => {\n    if (builtins.has(rule.head.predicate)) {\n      diagnostics.push({\n        code: 'builtin-head',\n        message: `rule defines built-in ${rule.head.predicate}`,\n        rule: index,\n        position: rule.position,\n      });\n    }\n    visitAtom(rule.head, index, rule.position);\n    rule.body.forEach((literal) => visitLiteral(literal, index, rule.position));\n\n    const head = new Set(Ast.variablesOf(rule.head.terms));\n    const plan = planBody({ body: rule.body, builtins, slots: new Slots(), outer: head });\n    for (const { literal, reason } of plan.unresolved) {\n      diagnostics.push({\n        code: 'unsafe',\n        message: `${reason} in: ${Ast.formatRule(rule)}`,\n        rule: index,\n        position: rule.body[literal].position ?? rule.position,\n      });\n    }\n    const unboundHead = [...head].filter((name) => !plan.bound.has(name));\n    if (unboundHead.length > 0) {\n      diagnostics.push({\n        code: 'unsafe',\n        message: `head variable ${unboundHead.join(', ')} is not bound by the body in: ${Ast.formatRule(rule)}`,\n        rule: index,\n        position: rule.position,\n      });\n    }\n    if (rule.head.terms.some((term) => term.type === 'variable' && term.anonymous)) {\n      diagnostics.push({\n        code: 'unsafe',\n        message: `anonymous variable in head of: ${Ast.formatRule(rule)}`,\n        rule: index,\n        position: rule.position,\n      });\n    }\n  });\n\n  const stratification = stratify(program.rules, builtins);\n  if (!stratification.ok) {\n    for (const cycle of stratification.cycles) {\n      diagnostics.push({\n        code: 'unstratifiable',\n        message: `negation or aggregation through recursion among: ${cycle.join(', ')}`,\n        rule: program.rules.findIndex((rule) => cycle.includes(rule.head.predicate)),\n        position: program.rules.find((rule) => cycle.includes(rule.head.predicate))?.position,\n      });\n    }\n  }\n  return diagnostics;\n};\n"],"mappings":"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"}