@dxos/datalog 0.0.1 → 0.12.0

package/dist/lib/chunk-Parser.mjs

@@ -0,0 +1,366 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { BaseError } from "@dxos/errors";
+//#region src/internal/lexer.ts
+/** A malformed token with the 1-based position where it starts. */
+var LexError = class extends BaseError.extend("LexError", "Invalid token") {
+	reason;
+	position;
+	constructor(reason, position) {
+		super({
+			message: reason,
+			context: {
+				line: position.line,
+				column: position.column
+			}
+		});
+		this.reason = reason;
+		this.position = position;
+	}
+};
+var PUNCTUATION = {
+	":": ":",
+	"(": "(",
+	")": ")",
+	"{": "{",
+	"}": "}",
+	",": ",",
+	".": ".",
+	"!": "!"
+};
+var ESCAPES = {
+	"n": "\n",
+	"t": "	",
+	"r": "\r",
+	"\\": "\\",
+	"\"": "\"",
+	"'": "'"
+};
+/** Splits dialect source into tokens with 1-based positions. */
+var tokenize = (source) => {
+	const tokens = [];
+	let offset = 0;
+	let line = 1;
+	let lineStart = 0;
+	const here = () => ({
+		line,
+		column: offset - lineStart + 1
+	});
+	const advance = (count) => {
+		for (let index = 0; index < count; index++) {
+			if (source[offset] === "\n") {
+				line++;
+				lineStart = offset + 1;
+			}
+			offset++;
+		}
+	};
+	while (offset < source.length) {
+		const char = source[offset];
+		const rest = source.slice(offset);
+		if (/\s/.test(char)) {
+			advance(1);
+			continue;
+		}
+		if (char === "%" || rest.startsWith("//")) {
+			while (offset < source.length && source[offset] !== "\n") advance(1);
+			continue;
+		}
+		if (rest.startsWith("/*")) {
+			const start = here();
+			const end = source.indexOf("*/", offset + 2);
+			if (end < 0) throw new LexError("Unterminated comment", start);
+			advance(end + 2 - offset);
+			continue;
+		}
+		const position = here();
+		if (char === "\"" || char === "'") {
+			let value = "";
+			let cursor = offset + 1;
+			while (cursor < source.length && source[cursor] !== char) {
+				if (source[cursor] === "\n") throw new LexError("Unterminated string", position);
+				if (source[cursor] === "\\") {
+					const escaped = source[cursor + 1];
+					value += ESCAPES[escaped] ?? escaped ?? "";
+					cursor += 2;
+				} else value += source[cursor++];
+			}
+			if (cursor >= source.length) throw new LexError("Unterminated string", position);
+			tokens.push({
+				type: "string",
+				text: source.slice(offset, cursor + 1),
+				value,
+				position
+			});
+			advance(cursor + 1 - offset);
+			continue;
+		}
+		const numeric = /^-?\d+(\.\d+)?(?![A-Za-z_\d])/.exec(rest);
+		if (numeric) {
+			tokens.push({
+				type: "number",
+				text: numeric[0],
+				value: Number(numeric[0]),
+				position
+			});
+			advance(numeric[0].length);
+			continue;
+		}
+		const word = /^[A-Za-z0-9_][A-Za-z0-9_]*/.exec(rest);
+		if (word) {
+			const text = word[0];
+			const type = /^[A-Z_]/.test(text) ? "variable" : "identifier";
+			tokens.push({
+				type,
+				text,
+				value: type === "identifier" ? text : void 0,
+				position
+			});
+			advance(text.length);
+			continue;
+		}
+		const operator = /^(<=|>=|!=|=|<|>)/.exec(rest);
+		if (operator) {
+			tokens.push({
+				type: "operator",
+				text: operator[0],
+				position
+			});
+			advance(operator[0].length);
+			continue;
+		}
+		if (rest.startsWith(":-")) {
+			tokens.push({
+				type: ":-",
+				text: ":-",
+				position
+			});
+			advance(2);
+			continue;
+		}
+		const punctuation = PUNCTUATION[char];
+		if (punctuation) {
+			tokens.push({
+				type: punctuation,
+				text: char,
+				position
+			});
+			advance(1);
+			continue;
+		}
+		throw new LexError(`Unexpected character '${char}'`, position);
+	}
+	return tokens;
+};
+//#endregion
+//#region src/Parser.ts
+var Parser_exports = /* @__PURE__ */ __exportAll({
+	ParseError: () => ParseError,
+	parse: () => parse
+});
+/** A syntax error with the 1-based position of the offending token. */
+var ParseError = class extends BaseError.extend("ParseError", "Syntax error") {
+	reason;
+	position;
+	constructor(reason, position) {
+		super({
+			message: reason,
+			context: {
+				line: position.line,
+				column: position.column
+			}
+		});
+		this.reason = reason;
+		this.position = position;
+	}
+};
+var AGGREGATES = [
+	"count",
+	"min",
+	"max",
+	"sum"
+];
+var isAggregateFunction = (text) => AGGREGATES.some((name) => name === text);
+var OPERATORS = [
+	"=",
+	"!=",
+	"<",
+	"<=",
+	">",
+	">="
+];
+var toOperator = (text) => OPERATORS.find((op) => op === text);
+/**
+* Parses dialect source (Soufflé-like: `head :- body.`, `not`/`!` negation, comparisons and
+* `N = count : { … }` aggregates) into a program.
+* @throws ParseError on the first syntax error.
+*/
+var parse = (source) => {
+	let tokens;
+	try {
+		tokens = tokenize(source);
+	} catch (error) {
+		if (error instanceof LexError) throw new ParseError(error.reason, error.position);
+		throw error;
+	}
+	let cursor = 0;
+	let anonymous = 0;
+	const end = () => {
+		const last = tokens.at(-1);
+		return last ? {
+			line: last.position.line,
+			column: last.position.column + last.text.length
+		} : {
+			line: 1,
+			column: 1
+		};
+	};
+	const peek = (ahead = 0) => tokens[cursor + ahead];
+	const fail = (expected, token = peek()) => {
+		throw new ParseError(token ? `Expected ${expected} but found '${token.text}'` : `Expected ${expected} but reached end of input`, token?.position ?? end());
+	};
+	const expect = (type, description = `'${type}'`) => {
+		const token = peek();
+		if (!token || token.type !== type) return fail(description);
+		cursor++;
+		return token;
+	};
+	const term = () => {
+		const token = peek();
+		switch (token?.type) {
+			case "variable":
+				cursor++;
+				return token.text === "_" ? {
+					type: "variable",
+					name: `_${anonymous++}`,
+					anonymous: true
+				} : {
+					type: "variable",
+					name: token.text
+				};
+			case "identifier":
+			case "string":
+			case "number":
+				cursor++;
+				return {
+					type: "constant",
+					value: token.value ?? token.text
+				};
+			default: return fail("a term");
+		}
+	};
+	const atom = () => {
+		const name = expect("identifier", "a predicate name");
+		const terms = [];
+		if (peek()?.type === "(") {
+			cursor++;
+			if (peek()?.type !== ")") {
+				terms.push(term());
+				while (peek()?.type === ",") {
+					cursor++;
+					terms.push(term());
+				}
+			}
+			expect(")", "',' or ')'");
+		}
+		return {
+			predicate: name.text,
+			terms
+		};
+	};
+	const aggregate = (result, position) => {
+		const name = expect("identifier", "an aggregate function");
+		if (!isAggregateFunction(name.text)) return fail("count, min, max or sum", name);
+		const target = name.text === "count" ? void 0 : term();
+		expect(":", "':'");
+		let body;
+		if (peek()?.type === "{") {
+			cursor++;
+			body = conjunction();
+			expect("}", "',' or '}'");
+		} else body = [literal()];
+		if (body.some((item) => item.type === "aggregate")) throw new ParseError("Aggregates cannot be nested", position);
+		return {
+			type: "aggregate",
+			function: name.text,
+			result,
+			target,
+			body,
+			position
+		};
+	};
+	/** `fn :` or `fn Term :` after `=`; unknown function names are reported by `aggregate`. */
+	const isAggregateAhead = () => peek()?.type === "identifier" && (peek(1)?.type === ":" || peek(2)?.type === ":");
+	const literal = () => {
+		const token = peek();
+		if (!token) return fail("a literal");
+		const position = token.position;
+		if (token.type === "!" || token.type === "identifier" && token.text === "not" && peek(1)?.type !== ":-") {
+			cursor++;
+			if (peek()?.type === "(" && token.type === "identifier") {
+				cursor++;
+				const negated = atom();
+				expect(")", "')'");
+				return {
+					type: "atom",
+					atom: negated,
+					negated: true,
+					position
+				};
+			}
+			return {
+				type: "atom",
+				atom: atom(),
+				negated: true,
+				position
+			};
+		}
+		if (peek(1)?.type === "operator" || token.type !== "identifier") {
+			const left = term();
+			const operatorToken = expect("operator", "a comparison operator");
+			const operator = toOperator(operatorToken.text) ?? fail("a comparison operator", operatorToken);
+			if (operator === "=" && isAggregateAhead()) return aggregate(left, position);
+			return {
+				type: "comparison",
+				operator,
+				left,
+				right: term(),
+				position
+			};
+		}
+		return {
+			type: "atom",
+			atom: atom(),
+			negated: false,
+			position
+		};
+	};
+	const conjunction = () => {
+		const literals = [literal()];
+		while (peek()?.type === ",") {
+			cursor++;
+			literals.push(literal());
+		}
+		return literals;
+	};
+	const rules = [];
+	while (cursor < tokens.length) {
+		const position = peek()?.position;
+		const head = atom();
+		let body = [];
+		if (peek()?.type === ":-") {
+			cursor++;
+			body = conjunction();
+		}
+		expect(".", "'.', ',' or ':-'");
+		rules.push({
+			head,
+			body,
+			position
+		});
+	}
+	return { rules };
+};
+//#endregion
+export { Parser_exports as n, parse as r, ParseError as t };
+
+//# sourceMappingURL=chunk-Parser.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-Parser.mjs","names":[],"sources":["../../src/internal/lexer.ts","../../src/Parser.ts"],"sourcesContent":["//\n// Copyright 2026 DXOS.org\n//\n\nimport { BaseError } from '@dxos/errors';\n\nimport type * as Ast from '../Ast.ts';\n\nexport type TokenType =\n  | 'identifier'\n  | 'variable'\n  | 'string'\n  | 'number'\n  | 'operator'\n  | ':-'\n  | ':'\n  | '('\n  | ')'\n  | '{'\n  | '}'\n  | ','\n  | '.'\n  | '!';\n\nexport type Token = {\n  readonly type: TokenType;\n  readonly text: string;\n  readonly value?: Ast.Value;\n  readonly position: Ast.Position;\n};\n\n/** A malformed token with the 1-based position where it starts. */\nexport class LexError extends BaseError.extend('LexError', 'Invalid token') {\n  constructor(\n    readonly reason: string,\n    readonly position: Ast.Position,\n  ) {\n    super({ message: reason, context: { line: position.line, column: position.column } });\n  }\n}\n\nconst PUNCTUATION: Record<string, TokenType | undefined> = {\n  ':': ':',\n  '(': '(',\n  ')': ')',\n  '{': '{',\n  '}': '}',\n  ',': ',',\n  '.': '.',\n  '!': '!',\n};\n\nconst ESCAPES: Record<string, string> = { 'n': '\\n', 't': '\\t', 'r': '\\r', '\\\\': '\\\\', '\"': '\"', \"'\": \"'\" };\n\n/** Splits dialect source into tokens with 1-based positions. */\nexport const tokenize = (source: string): Token[] => {\n  const tokens: Token[] = [];\n  let offset = 0;\n  let line = 1;\n  let lineStart = 0;\n  const here = (): Ast.Position => ({ line, column: offset - lineStart + 1 });\n  const advance = (count: number) => {\n    for (let index = 0; index < count; index++) {\n      if (source[offset] === '\\n') {\n        line++;\n        lineStart = offset + 1;\n      }\n      offset++;\n    }\n  };\n\n  while (offset < source.length) {\n    const char = source[offset];\n    const rest = source.slice(offset);\n    if (/\\s/.test(char)) {\n      advance(1);\n      continue;\n    }\n    if (char === '%' || rest.startsWith('//')) {\n      while (offset < source.length && source[offset] !== '\\n') {\n        advance(1);\n      }\n      continue;\n    }\n    if (rest.startsWith('/*')) {\n      const start = here();\n      const end = source.indexOf('*/', offset + 2);\n      if (end < 0) {\n        throw new LexError('Unterminated comment', start);\n      }\n      advance(end + 2 - offset);\n      continue;\n    }\n\n    const position = here();\n    if (char === '\"' || char === \"'\") {\n      let value = '';\n      let cursor = offset + 1;\n      while (cursor < source.length && source[cursor] !== char) {\n        if (source[cursor] === '\\n') {\n          throw new LexError('Unterminated string', position);\n        }\n        if (source[cursor] === '\\\\') {\n          const escaped = source[cursor + 1];\n          value += ESCAPES[escaped] ?? escaped ?? '';\n          cursor += 2;\n        } else {\n          value += source[cursor++];\n        }\n      }\n      if (cursor >= source.length) {\n        throw new LexError('Unterminated string', position);\n      }\n      tokens.push({ type: 'string', text: source.slice(offset, cursor + 1), value, position });\n      advance(cursor + 1 - offset);\n      continue;\n    }\n\n    // A digit run glued to letters (`2d`, `30d`) is a symbol, which keeps durations unquoted.\n    const numeric = /^-?\\d+(\\.\\d+)?(?![A-Za-z_\\d])/.exec(rest);\n    if (numeric) {\n      tokens.push({ type: 'number', text: numeric[0], value: Number(numeric[0]), position });\n      advance(numeric[0].length);\n      continue;\n    }\n    const word = /^[A-Za-z0-9_][A-Za-z0-9_]*/.exec(rest);\n    if (word) {\n      const text = word[0];\n      const type: TokenType = /^[A-Z_]/.test(text) ? 'variable' : 'identifier';\n      tokens.push({ type, text, value: type === 'identifier' ? text : undefined, position });\n      advance(text.length);\n      continue;\n    }\n    const operator = /^(<=|>=|!=|=|<|>)/.exec(rest);\n    if (operator) {\n      tokens.push({ type: 'operator', text: operator[0], position });\n      advance(operator[0].length);\n      continue;\n    }\n    if (rest.startsWith(':-')) {\n      tokens.push({ type: ':-', text: ':-', position });\n      advance(2);\n      continue;\n    }\n    const punctuation = PUNCTUATION[char];\n    if (punctuation) {\n      tokens.push({ type: punctuation, text: char, position });\n      advance(1);\n      continue;\n    }\n    throw new LexError(`Unexpected character '${char}'`, position);\n  }\n  return tokens;\n};\n","//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\nimport { BaseError } from '@dxos/errors';\n\nimport type * as Ast from './Ast.ts';\nimport { LexError, type Token, tokenize } from './internal/lexer.ts';\n\n/** A syntax error with the 1-based position of the offending token. */\nexport class ParseError extends BaseError.extend('ParseError', 'Syntax error') {\n  constructor(\n    readonly reason: string,\n    readonly position: Ast.Position,\n  ) {\n    super({ message: reason, context: { line: position.line, column: position.column } });\n  }\n}\n\nconst AGGREGATES: ReadonlyArray<Ast.AggregateFunction> = ['count', 'min', 'max', 'sum'];\n\nconst isAggregateFunction = (text: string): text is Ast.AggregateFunction => AGGREGATES.some((name) => name === text);\n\nconst OPERATORS: ReadonlyArray<Ast.ComparisonOperator> = ['=', '!=', '<', '<=', '>', '>='];\n\nconst toOperator = (text: string): Ast.ComparisonOperator | undefined => OPERATORS.find((op) => op === text);\n\n/**\n * Parses dialect source (Soufflé-like: `head :- body.`, `not`/`!` negation, comparisons and\n * `N = count : { … }` aggregates) into a program.\n * @throws ParseError on the first syntax error.\n */\nexport const parse = (source: string): Ast.Program => {\n  let tokens: Token[];\n  try {\n    tokens = tokenize(source);\n  } catch (error) {\n    if (error instanceof LexError) {\n      throw new ParseError(error.reason, error.position);\n    }\n    throw error;\n  }\n\n  let cursor = 0;\n  let anonymous = 0;\n  const end = (): Ast.Position => {\n    const last = tokens.at(-1);\n    return last\n      ? { line: last.position.line, column: last.position.column + last.text.length }\n      : { line: 1, column: 1 };\n  };\n  const peek = (ahead = 0): Token | undefined => tokens[cursor + ahead];\n  const fail = (expected: string, token = peek()): never => {\n    throw new ParseError(\n      token ? `Expected ${expected} but found '${token.text}'` : `Expected ${expected} but reached end of input`,\n      token?.position ?? end(),\n    );\n  };\n  const expect = (type: Token['type'], description = `'${type}'`): Token => {\n    const token = peek();\n    if (!token || token.type !== type) {\n      return fail(description);\n    }\n    cursor++;\n    return token;\n  };\n\n  const term = (): Ast.Term => {\n    const token = peek();\n    switch (token?.type) {\n      case 'variable':\n        cursor++;\n        return token.text === '_'\n          ? { type: 'variable', name: `_${anonymous++}`, anonymous: true }\n          : { type: 'variable', name: token.text };\n      case 'identifier':\n      case 'string':\n      case 'number':\n        cursor++;\n        return { type: 'constant', value: token.value ?? token.text };\n      default:\n        return fail('a term');\n    }\n  };\n\n  const atom = (): Ast.Atom => {\n    const name = expect('identifier', 'a predicate name');\n    const terms: Ast.Term[] = [];\n    if (peek()?.type === '(') {\n      cursor++;\n      if (peek()?.type !== ')') {\n        terms.push(term());\n        while (peek()?.type === ',') {\n          cursor++;\n          terms.push(term());\n        }\n      }\n      expect(')', \"',' or ')'\");\n    }\n    return { predicate: name.text, terms };\n  };\n\n  const aggregate = (result: Ast.Term, position: Ast.Position): Ast.AggregateLiteral => {\n    const name = expect('identifier', 'an aggregate function');\n    if (!isAggregateFunction(name.text)) {\n      return fail('count, min, max or sum', name);\n    }\n    const target = name.text === 'count' ? undefined : term();\n    expect(':', \"':'\");\n    let body: Ast.Literal[];\n    if (peek()?.type === '{') {\n      cursor++;\n      body = conjunction();\n      expect('}', \"',' or '}'\");\n    } else {\n      body = [literal()];\n    }\n    if (body.some((item) => item.type === 'aggregate')) {\n      throw new ParseError('Aggregates cannot be nested', position);\n    }\n    return { type: 'aggregate', function: name.text, result, target, body, position };\n  };\n\n  /** `fn :` or `fn Term :` after `=`; unknown function names are reported by `aggregate`. */\n  const isAggregateAhead = (): boolean =>\n    peek()?.type === 'identifier' && (peek(1)?.type === ':' || peek(2)?.type === ':');\n\n  const literal = (): Ast.Literal => {\n    const token = peek();\n    if (!token) {\n      return fail('a literal');\n    }\n    const position = token.position;\n    if (token.type === '!' || (token.type === 'identifier' && token.text === 'not' && peek(1)?.type !== ':-')) {\n      cursor++;\n      if (peek()?.type === '(' && token.type === 'identifier') {\n        cursor++;\n        const negated = atom();\n        expect(')', \"')'\");\n        return { type: 'atom', atom: negated, negated: true, position };\n      }\n      return { type: 'atom', atom: atom(), negated: true, position };\n    }\n    if (peek(1)?.type === 'operator' || token.type !== 'identifier') {\n      const left = term();\n      const operatorToken = expect('operator', 'a comparison operator');\n      const operator = toOperator(operatorToken.text) ?? fail('a comparison operator', operatorToken);\n      if (operator === '=' && isAggregateAhead()) {\n        return aggregate(left, position);\n      }\n      return { type: 'comparison', operator, left, right: term(), position };\n    }\n    return { type: 'atom', atom: atom(), negated: false, position };\n  };\n\n  const conjunction = (): Ast.Literal[] => {\n    const literals = [literal()];\n    while (peek()?.type === ',') {\n      cursor++;\n      literals.push(literal());\n    }\n    return literals;\n  };\n\n  const rules: Ast.Rule[] = [];\n  while (cursor < tokens.length) {\n    const position = peek()?.position;\n    const head = atom();\n    let body: Ast.Literal[] = [];\n    if (peek()?.type === ':-') {\n      cursor++;\n      body = conjunction();\n    }\n    expect('.', \"'.', ',' or ':-'\");\n    rules.push({ head, body, position });\n  }\n  return { rules };\n};\n"],"mappings":";;;;AAgCA,IAAa,WAAb,cAA8B,UAAU,OAAO,YAAY,eAAe,CAAC,CAAC;CAE/D;CACA;CAFX,YACE,QACA,UACA;EACA,MAAM;GAAE,SAAS;GAAQ,SAAS;IAAE,MAAM,SAAS;IAAM,QAAQ,SAAS;GAAO;EAAE,CAAC;EAH3E,KAAA,SAAA;EACA,KAAA,WAAA;CAGX;AACF;AAEA,IAAM,cAAqD;CACzD,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;AACP;AAEA,IAAM,UAAkC;CAAE,KAAK;CAAM,KAAK;CAAM,KAAK;CAAM,MAAM;CAAM,MAAK;CAAK,KAAK;AAAI;;AAG1G,IAAa,YAAY,WAA4B;CACnD,MAAM,SAAkB,CAAC;CACzB,IAAI,SAAS;CACb,IAAI,OAAO;CACX,IAAI,YAAY;CAChB,MAAM,cAA4B;EAAE;EAAM,QAAQ,SAAS,YAAY;CAAE;CACzE,MAAM,WAAW,UAAkB;EACjC,KAAK,IAAI,QAAQ,GAAG,QAAQ,OAAO,SAAS;GAC1C,IAAI,OAAO,YAAY,MAAM;IAC3B;IACA,YAAY,SAAS;GACvB;GACA;EACF;CACF;CAEA,OAAO,SAAS,OAAO,QAAQ;EAC7B,MAAM,OAAO,OAAO;EACpB,MAAM,OAAO,OAAO,MAAM,MAAM;EAChC,IAAI,KAAK,KAAK,IAAI,GAAG;GACnB,QAAQ,CAAC;GACT;EACF;EACA,IAAI,SAAS,OAAO,KAAK,WAAW,IAAI,GAAG;GACzC,OAAO,SAAS,OAAO,UAAU,OAAO,YAAY,MAClD,QAAQ,CAAC;GAEX;EACF;EACA,IAAI,KAAK,WAAW,IAAI,GAAG;GACzB,MAAM,QAAQ,KAAK;GACnB,MAAM,MAAM,OAAO,QAAQ,MAAM,SAAS,CAAC;GAC3C,IAAI,MAAM,GACR,MAAM,IAAI,SAAS,wBAAwB,KAAK;GAElD,QAAQ,MAAM,IAAI,MAAM;GACxB;EACF;EAEA,MAAM,WAAW,KAAK;EACtB,IAAI,SAAS,QAAO,SAAS,KAAK;GAChC,IAAI,QAAQ;GACZ,IAAI,SAAS,SAAS;GACtB,OAAO,SAAS,OAAO,UAAU,OAAO,YAAY,MAAM;IACxD,IAAI,OAAO,YAAY,MACrB,MAAM,IAAI,SAAS,uBAAuB,QAAQ;IAEpD,IAAI,OAAO,YAAY,MAAM;KAC3B,MAAM,UAAU,OAAO,SAAS;KAChC,SAAS,QAAQ,YAAY,WAAW;KACxC,UAAU;IACZ,OACE,SAAS,OAAO;GAEpB;GACA,IAAI,UAAU,OAAO,QACnB,MAAM,IAAI,SAAS,uBAAuB,QAAQ;GAEpD,OAAO,KAAK;IAAE,MAAM;IAAU,MAAM,OAAO,MAAM,QAAQ,SAAS,CAAC;IAAG;IAAO;GAAS,CAAC;GACvF,QAAQ,SAAS,IAAI,MAAM;GAC3B;EACF;EAGA,MAAM,UAAU,gCAAgC,KAAK,IAAI;EACzD,IAAI,SAAS;GACX,OAAO,KAAK;IAAE,MAAM;IAAU,MAAM,QAAQ;IAAI,OAAO,OAAO,QAAQ,EAAE;IAAG;GAAS,CAAC;GACrF,QAAQ,QAAQ,EAAE,CAAC,MAAM;GACzB;EACF;EACA,MAAM,OAAO,6BAA6B,KAAK,IAAI;EACnD,IAAI,MAAM;GACR,MAAM,OAAO,KAAK;GAClB,MAAM,OAAkB,UAAU,KAAK,IAAI,IAAI,aAAa;GAC5D,OAAO,KAAK;IAAE;IAAM;IAAM,OAAO,SAAS,eAAe,OAAO,KAAA;IAAW;GAAS,CAAC;GACrF,QAAQ,KAAK,MAAM;GACnB;EACF;EACA,MAAM,WAAW,oBAAoB,KAAK,IAAI;EAC9C,IAAI,UAAU;GACZ,OAAO,KAAK;IAAE,MAAM;IAAY,MAAM,SAAS;IAAI;GAAS,CAAC;GAC7D,QAAQ,SAAS,EAAE,CAAC,MAAM;GAC1B;EACF;EACA,IAAI,KAAK,WAAW,IAAI,GAAG;GACzB,OAAO,KAAK;IAAE,MAAM;IAAM,MAAM;IAAM;GAAS,CAAC;GAChD,QAAQ,CAAC;GACT;EACF;EACA,MAAM,cAAc,YAAY;EAChC,IAAI,aAAa;GACf,OAAO,KAAK;IAAE,MAAM;IAAa,MAAM;IAAM;GAAS,CAAC;GACvD,QAAQ,CAAC;GACT;EACF;EACA,MAAM,IAAI,SAAS,yBAAyB,KAAK,IAAI,QAAQ;CAC/D;CACA,OAAO;AACT;;;;;;;;AC7IA,IAAa,aAAb,cAAgC,UAAU,OAAO,cAAc,cAAc,CAAC,CAAC;CAElE;CACA;CAFX,YACE,QACA,UACA;EACA,MAAM;GAAE,SAAS;GAAQ,SAAS;IAAE,MAAM,SAAS;IAAM,QAAQ,SAAS;GAAO;EAAE,CAAC;EAH3E,KAAA,SAAA;EACA,KAAA,WAAA;CAGX;AACF;AAEA,IAAM,aAAmD;CAAC;CAAS;CAAO;CAAO;AAAK;AAEtF,IAAM,uBAAuB,SAAgD,WAAW,MAAM,SAAS,SAAS,IAAI;AAEpH,IAAM,YAAmD;CAAC;CAAK;CAAM;CAAK;CAAM;CAAK;AAAI;AAEzF,IAAM,cAAc,SAAqD,UAAU,MAAM,OAAO,OAAO,IAAI;;;;;;AAO3G,IAAa,SAAS,WAAgC;CACpD,IAAI;CACJ,IAAI;EACF,SAAS,SAAS,MAAM;CAC1B,SAAS,OAAO;EACd,IAAI,iBAAiB,UACnB,MAAM,IAAI,WAAW,MAAM,QAAQ,MAAM,QAAQ;EAEnD,MAAM;CACR;CAEA,IAAI,SAAS;CACb,IAAI,YAAY;CAChB,MAAM,YAA0B;EAC9B,MAAM,OAAO,OAAO,GAAG,EAAE;EACzB,OAAO,OACH;GAAE,MAAM,KAAK,SAAS;GAAM,QAAQ,KAAK,SAAS,SAAS,KAAK,KAAK;EAAO,IAC5E;GAAE,MAAM;GAAG,QAAQ;EAAE;CAC3B;CACA,MAAM,QAAQ,QAAQ,MAAyB,OAAO,SAAS;CAC/D,MAAM,QAAQ,UAAkB,QAAQ,KAAK,MAAa;EACxD,MAAM,IAAI,WACR,QAAQ,YAAY,SAAS,cAAc,MAAM,KAAK,KAAK,YAAY,SAAS,4BAChF,OAAO,YAAY,IAAI,CACzB;CACF;CACA,MAAM,UAAU,MAAqB,cAAc,IAAI,KAAK,OAAc;EACxE,MAAM,QAAQ,KAAK;EACnB,IAAI,CAAC,SAAS,MAAM,SAAS,MAC3B,OAAO,KAAK,WAAW;EAEzB;EACA,OAAO;CACT;CAEA,MAAM,aAAuB;EAC3B,MAAM,QAAQ,KAAK;EACnB,QAAQ,OAAO,MAAf;GACE,KAAK;IACH;IACA,OAAO,MAAM,SAAS,MAClB;KAAE,MAAM;KAAY,MAAM,IAAI;KAAe,WAAW;IAAK,IAC7D;KAAE,MAAM;KAAY,MAAM,MAAM;IAAK;GAC3C,KAAK;GACL,KAAK;GACL,KAAK;IACH;IACA,OAAO;KAAE,MAAM;KAAY,OAAO,MAAM,SAAS,MAAM;IAAK;GAC9D,SACE,OAAO,KAAK,QAAQ;EACxB;CACF;CAEA,MAAM,aAAuB;EAC3B,MAAM,OAAO,OAAO,cAAc,kBAAkB;EACpD,MAAM,QAAoB,CAAC;EAC3B,IAAI,KAAK,CAAC,EAAE,SAAS,KAAK;GACxB;GACA,IAAI,KAAK,CAAC,EAAE,SAAS,KAAK;IACxB,MAAM,KAAK,KAAK,CAAC;IACjB,OAAO,KAAK,CAAC,EAAE,SAAS,KAAK;KAC3B;KACA,MAAM,KAAK,KAAK,CAAC;IACnB;GACF;GACA,OAAO,KAAK,YAAY;EAC1B;EACA,OAAO;GAAE,WAAW,KAAK;GAAM;EAAM;CACvC;CAEA,MAAM,aAAa,QAAkB,aAAiD;EACpF,MAAM,OAAO,OAAO,cAAc,uBAAuB;EACzD,IAAI,CAAC,oBAAoB,KAAK,IAAI,GAChC,OAAO,KAAK,0BAA0B,IAAI;EAE5C,MAAM,SAAS,KAAK,SAAS,UAAU,KAAA,IAAY,KAAK;EACxD,OAAO,KAAK,KAAK;EACjB,IAAI;EACJ,IAAI,KAAK,CAAC,EAAE,SAAS,KAAK;GACxB;GACA,OAAO,YAAY;GACnB,OAAO,KAAK,YAAY;EAC1B,OACE,OAAO,CAAC,QAAQ,CAAC;EAEnB,IAAI,KAAK,MAAM,SAAS,KAAK,SAAS,WAAW,GAC/C,MAAM,IAAI,WAAW,+BAA+B,QAAQ;EAE9D,OAAO;GAAE,MAAM;GAAa,UAAU,KAAK;GAAM;GAAQ;GAAQ;GAAM;EAAS;CAClF;;CAGA,MAAM,yBACJ,KAAK,CAAC,EAAE,SAAS,iBAAiB,KAAK,CAAC,CAAC,EAAE,SAAS,OAAO,KAAK,CAAC,CAAC,EAAE,SAAS;CAE/E,MAAM,gBAA6B;EACjC,MAAM,QAAQ,KAAK;EACnB,IAAI,CAAC,OACH,OAAO,KAAK,WAAW;EAEzB,MAAM,WAAW,MAAM;EACvB,IAAI,MAAM,SAAS,OAAQ,MAAM,SAAS,gBAAgB,MAAM,SAAS,SAAS,KAAK,CAAC,CAAC,EAAE,SAAS,MAAO;GACzG;GACA,IAAI,KAAK,CAAC,EAAE,SAAS,OAAO,MAAM,SAAS,cAAc;IACvD;IACA,MAAM,UAAU,KAAK;IACrB,OAAO,KAAK,KAAK;IACjB,OAAO;KAAE,MAAM;KAAQ,MAAM;KAAS,SAAS;KAAM;IAAS;GAChE;GACA,OAAO;IAAE,MAAM;IAAQ,MAAM,KAAK;IAAG,SAAS;IAAM;GAAS;EAC/D;EACA,IAAI,KAAK,CAAC,CAAC,EAAE,SAAS,cAAc,MAAM,SAAS,cAAc;GAC/D,MAAM,OAAO,KAAK;GAClB,MAAM,gBAAgB,OAAO,YAAY,uBAAuB;GAChE,MAAM,WAAW,WAAW,cAAc,IAAI,KAAK,KAAK,yBAAyB,aAAa;GAC9F,IAAI,aAAa,OAAO,iBAAiB,GACvC,OAAO,UAAU,MAAM,QAAQ;GAEjC,OAAO;IAAE,MAAM;IAAc;IAAU;IAAM,OAAO,KAAK;IAAG;GAAS;EACvE;EACA,OAAO;GAAE,MAAM;GAAQ,MAAM,KAAK;GAAG,SAAS;GAAO;EAAS;CAChE;CAEA,MAAM,oBAAmC;EACvC,MAAM,WAAW,CAAC,QAAQ,CAAC;EAC3B,OAAO,KAAK,CAAC,EAAE,SAAS,KAAK;GAC3B;GACA,SAAS,KAAK,QAAQ,CAAC;EACzB;EACA,OAAO;CACT;CAEA,MAAM,QAAoB,CAAC;CAC3B,OAAO,SAAS,OAAO,QAAQ;EAC7B,MAAM,WAAW,KAAK,CAAC,EAAE;EACzB,MAAM,OAAO,KAAK;EAClB,IAAI,OAAsB,CAAC;EAC3B,IAAI,KAAK,CAAC,EAAE,SAAS,MAAM;GACzB;GACA,OAAO,YAAY;EACrB;EACA,OAAO,KAAK,kBAAkB;EAC9B,MAAM,KAAK;GAAE;GAAM;GAAM;EAAS,CAAC;CACrC;CACA,OAAO,EAAE,MAAM;AACjB"}

package/dist/lib/chunk-rolldown-runtime.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/lib/index.mjs

@@ -0,0 +1,6 @@
+import { t as Ast_exports } from "./Ast.mjs";
+import { t as Builtin_exports } from "./Builtin.mjs";
+import { n as Checker_exports } from "./chunk-Checker.mjs";
+import { n as Engine_exports } from "./chunk-Engine.mjs";
+import { n as Parser_exports } from "./chunk-Parser.mjs";
+export { Ast_exports as Ast, Builtin_exports as Builtin, Checker_exports as Checker, Engine_exports as Engine, Parser_exports as Parser };

package/dist/types/src/Ast.d.ts

@@ -0,0 +1,81 @@
+/** A ground value; symbols (`dima`) and strings (`"dima"`) are the same value. */
+export type Value = string | number;
+/** A ground row of a relation. */
+export type Tuple = ReadonlyArray<Value>;
+/** Source location (1-based line and column). */
+export type Position = {
+    readonly line: number;
+    readonly column: number;
+};
+export type Variable = {
+    readonly type: 'variable';
+    readonly name: string;
+    /** Set for `_`; each occurrence is a distinct, never-joined variable. */
+    readonly anonymous?: boolean;
+};
+export type Constant = {
+    readonly type: 'constant';
+    readonly value: Value;
+};
+export type Term = Variable | Constant;
+export type Atom = {
+    readonly predicate: string;
+    readonly terms: ReadonlyArray<Term>;
+};
+export type ComparisonOperator = '=' | '!=' | '<' | '<=' | '>' | '>=';
+export type AggregateFunction = 'count' | 'min' | 'max' | 'sum';
+export type AtomLiteral = {
+    readonly type: 'atom';
+    readonly atom: Atom;
+    readonly negated: boolean;
+    readonly position?: Position;
+};
+export type ComparisonLiteral = {
+    readonly type: 'comparison';
+    readonly operator: ComparisonOperator;
+    readonly left: Term;
+    readonly right: Term;
+    readonly position?: Position;
+};
+/** `Result = fn Target : { body }`; `Target` is absent for `count`. */
+export type AggregateLiteral = {
+    readonly type: 'aggregate';
+    readonly function: AggregateFunction;
+    readonly result: Term;
+    readonly target?: Term;
+    readonly body: ReadonlyArray<Literal>;
+    readonly position?: Position;
+};
+export type Literal = AtomLiteral | ComparisonLiteral | AggregateLiteral;
+/** A rule; a fact is a rule with an empty body. */
+export type Rule = {
+    readonly head: Atom;
+    readonly body: ReadonlyArray<Literal>;
+    readonly position?: Position;
+};
+export type Program = {
+    readonly rules: ReadonlyArray<Rule>;
+};
+/** Creates a variable term. */
+export declare const variable: (name: string) => Variable;
+/** Creates a constant term. */
+export declare const constant: (value: Value) => Constant;
+/** Creates an atom. */
+export declare const atom: (predicate: string, terms: ReadonlyArray<Term>) => Atom;
+/** Named (non-anonymous) variables of a term list, in order of first occurrence. */
+export declare const variablesOf: (terms: ReadonlyArray<Term>) => string[];
+/** Named variables a literal mentions, including those inside an aggregate body. */
+export declare const literalVariables: (literal: Literal) => string[];
+/** Formats a value as dialect source. */
+export declare const formatValue: (value: Value) => string;
+/** Formats a term as dialect source. */
+export declare const formatTerm: (term: Term) => string;
+/** Formats an atom as dialect source. */
+export declare const formatAtom: (atom: Atom) => string;
+/** Formats a literal as dialect source. */
+export declare const formatLiteral: (literal: Literal) => string;
+/** Formats a rule as dialect source. */
+export declare const formatRule: (rule: Rule) => string;
+/** Formats a program as dialect source, one rule per line. */
+export declare const format: (program: Program) => string;
+//# sourceMappingURL=Ast.d.ts.map

package/dist/types/src/Ast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ast.d.ts","sourceRoot":"","sources":["../../../src/Ast.ts"],"names":[],"mappings":"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"}

package/dist/types/src/Builtin.d.ts

@@ -0,0 +1,35 @@
+import type * as Ast from './Ast.ts';
+/**
+ * A binding pattern, one character per argument: `b` must be bound before the call, `f` may be
+ * free and is bound by the call. `"fb"` lets the first argument be generated from the second.
+ */
+export type Mode = string;
+/** Arguments as seen by a built-in: `undefined` marks a free position of the selected mode. */
+export type Arguments = ReadonlyArray<Ast.Value | undefined>;
+/** A predicate implemented in code rather than by rules. */
+export type Builtin = {
+    readonly name: string;
+    readonly arity: number;
+    /** Accepted binding patterns; the all-bound pattern is always accepted. */
+    readonly modes: ReadonlyArray<Mode>;
+    /**
+     * Set when the result can change with no change to the facts (a clock), so the engine
+     * re-evaluates the rules that use it on `refresh`.
+     */
+    readonly volatile?: boolean;
+    /** Returns every full argument tuple that holds and agrees with the bound arguments. */
+    readonly evaluate: (args: Arguments) => Iterable<Ast.Tuple>;
+};
+/** Built-ins by name. */
+export type Registry = ReadonlyMap<string, Builtin>;
+/** Defines a built-in. */
+export declare const make: (builtin: Builtin) => Builtin;
+/** Defines a test-only built-in: holds iff `test` returns true for its fully bound arguments. */
+export declare const predicate: (name: string, arity: number, test: (args: Ast.Tuple) => boolean, options?: {
+    volatile?: boolean;
+}) => Builtin;
+/** Builds a registry, rejecting duplicate names. */
+export declare const registry: (...builtins: ReadonlyArray<Builtin>) => Registry;
+/** True if `builtin` can be called with exactly the `bound` argument positions bound. */
+export declare const acceptsBinding: (builtin: Builtin, bound: ReadonlyArray<boolean>) => boolean;
+//# sourceMappingURL=Builtin.d.ts.map

package/dist/types/src/Builtin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Builtin.d.ts","sourceRoot":"","sources":["../../../src/Builtin.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,KAAK,GAAG,MAAM,UAAU,CAAC;AAErC;;;GAGG;AACH,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC;AAE1B,+FAA+F;AAC/F,MAAM,MAAM,SAAS,GAAG,aAAa,CAAC,GAAG,CAAC,KAAK,GAAG,SAAS,CAAC,CAAC;AAE7D,4DAA4D;AAC5D,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC;IACpC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,wFAAwF;IACxF,QAAQ,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;CAC7D,CAAC;AAEF,yBAAyB;AACzB,MAAM,MAAM,QAAQ,GAAG,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpD,0BAA0B;AAC1B,eAAO,MAAM,IAAI,YAAa,OAAO,KAAG,OAAkB,CAAC;AAE3D,iGAAiG;AACjG,eAAO,MAAM,SAAS,SACd,MAAM,SACL,MAAM,QACP,CAAC,IAAI,EAAE,GAAG,CAAC,KAAK,KAAK,OAAO,YACzB;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,KAC9B,OASD,CAAC;AAEH,oDAAoD;AACpD,eAAO,MAAM,QAAQ,gBAAiB,aAAa,CAAC,OAAO,CAAC,KAAG,QAY9D,CAAC;AAEF,yFAAyF;AACzF,eAAO,MAAM,cAAc,YAAa,OAAO,SAAS,aAAa,CAAC,OAAO,CAAC,KAAG,OACqC,CAAC"}

package/dist/types/src/Checker.d.ts

@@ -0,0 +1,61 @@
+import { BaseError } from '@dxos/errors';
+import * as Ast from './Ast.ts';
+import type * as Builtin from './Builtin.ts';
+export type DiagnosticCode = 'arity' | 'builtin-head' | 'undefined' | 'unsafe' | 'unstratifiable';
+/** A static error in a program. */
+export type Diagnostic = {
+    readonly code: DiagnosticCode;
+    readonly message: string;
+    /** Index of the offending rule. */
+    readonly rule?: number;
+    readonly position?: Ast.Position;
+};
+export type Options = {
+    readonly builtins?: Builtin.Registry;
+    /**
+     * Base relations and their arities. When given, a body predicate that is neither defined by a
+     * rule, declared here nor a built-in is reported as `undefined`.
+     */
+    readonly relations?: Readonly<Record<string, number>>;
+};
+declare const CheckError_base: {
+    new (options?: import("@dxos/errors").BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "CheckError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "CheckError";
+    };
+    isError(error: unknown): error is Error;
+    name: "CheckError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "CheckError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "CheckError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+/** Thrown when a program with diagnostics is evaluated. */
+export declare class CheckError extends CheckError_base {
+    readonly diagnostics: ReadonlyArray<Diagnostic>;
+    constructor(diagnostics: ReadonlyArray<Diagnostic>);
+}
+/** Formats a diagnostic as `line:column code: message`. */
+export declare const formatDiagnostic: (diagnostic: Diagnostic) => string;
+/**
+ * Checks arity consistency, built-in heads, undefined predicates, range restriction (safety) and
+ * stratification; an empty result means the program can be evaluated.
+ */
+export declare const check: (program: Ast.Program, options?: Options) => Diagnostic[];
+export {};
+//# sourceMappingURL=Checker.d.ts.map

package/dist/types/src/Checker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Checker.d.ts","sourceRoot":"","sources":["../../../src/Checker.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAChC,OAAO,KAAK,KAAK,OAAO,MAAM,cAAc,CAAC;AAI7C,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,cAAc,GAAG,WAAW,GAAG,QAAQ,GAAG,gBAAgB,CAAC;AAElG,mCAAmC;AACnC,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,mCAAmC;IACnC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE,GAAG,CAAC,QAAQ,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC;IACrC;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACvD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEF,2DAA2D;AAC3D,qBAAa,UAAW,SAAQ,eAAiD;IAE/E,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;IAEhD,YAAY,WAAW,EAAE,aAAa,CAAC,UAAU,CAAC,EAGjD;CACF;AAED,2DAA2D;AAC3D,eAAO,MAAM,gBAAgB,eAAgB,UAAU,KAAG,MAGzD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,KAAK,YAAa,GAAG,CAAC,OAAO,YAAW,OAAO,KAAQ,UAAU,EAqG7E,CAAC"}

package/dist/types/src/Checker.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Checker.test.d.ts.map

package/dist/types/src/Checker.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Checker.test.d.ts","sourceRoot":"","sources":["../../../src/Checker.test.ts"],"names":[],"mappings":""}