@dxos/datalog 0.0.1 → 0.13.0

package/LICENSE

@@ -0,0 +1,105 @@
+# Functional Source License, Version 1.1, ALv2 Future License
+
+## Abbreviation
+
+FSL-1.1-Apache-2.0
+
+## Notice
+
+Copyright 2026 DXOS
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the Apache License, Version 2.0 that is effective on the second anniversary of
+the date we make the Software available. On or after that date, you may use the
+Software under the Apache License, Version 2.0, in which case the following
+will apply:
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License.
+
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.

package/README.md

@@ -1,3 +1,60 @@
 # @dxos/datalog
 
-Placeholder release that registers the package name. See https://github.com/dxos/dxos.
+A small Datalog engine with no third-party dependencies: a parser for a Soufflé-like dialect, static checks, and an
+incremental stratified semi-naive evaluator with provenance and pluggable built-ins. It is plain
+TypeScript with no Node built-ins, `eval` or threads, so it runs unchanged in the browser, in a
+workerd Durable Object and in Node.
+
+## Dialect
+
+```prolog
+% Facts and rules; lowercase words and "strings" are the same symbol, numbers are numbers.
+edge(a, b).
+path(X, Y) :- edge(X, Y).
+path(X, Z) :- path(X, Y), edge(Y, Z).
+
+% Stratified negation (`not p(…)`, `!p(…)`), anonymous variables and comparisons.
+isolated(X) :- node(X), not path(X, _), X != root.
+
+% Aggregates: count, min, max and sum over a body; variables shared with the rule correlate it.
+degree(X, N) :- node(X), N = count : { edge(X, _) }.
+
+% Built-ins are called like relations; `2d` is a symbol, so durations need no quotes.
+followup :- elapsed(goal, 2d), not achieved(goal).
+```
+
+No disjunction, functions or existential heads: every program terminates.
+
+## Usage
+
+```ts
+import { Builtin, Checker, Engine, Parser } from '@dxos/datalog';
+
+const program = Parser.parse(source); // throws Parser.ParseError with line and column
+const diagnostics = Checker.check(program, { builtins, relations: { edge: 2 } });
+
+const engine = Engine.make({ program, builtins });
+const changes = engine.insert('edge', ['a', 'b']); // only the tuples this insert added or removed
+engine.update({ refresh: true }); // re-evaluate volatile built-ins (a clock tick)
+engine.provenance('path', ['a', 'b']); // the base tuples one derivation rests on
+```
+
+- **Checks** (`Checker.check`) return structured diagnostics: `arity`, `undefined` (when base
+  relations are declared), `builtin-head`, `unsafe` (every head variable and every variable under
+  `not` or in a comparison must be bound by a positive literal or a built-in mode that binds it) and
+  `unstratifiable` (negation or aggregation through recursion).
+- **Built-ins** (`Builtin.make`) declare binding modes: `"fb"` means the first argument may be free and
+  is bound by the call. A `volatile` built-in (one that reads a clock) is re-evaluated on `refresh`.
+- **Incremental evaluation**: insertions propagate semi-naively; a stratum is recomputed and diffed
+  only when a relation it reads under negation or aggregation changed, or a relation it reads lost
+  tuples. `Changes.added` is the "new binding" signal callers wake on.
+- **Provenance**: one derivation is kept per derived tuple (the rule and the tuples its positive
+  literals matched). Aggregates and negation contribute no premises.
+- **Rewrites**: the AST (`Ast`) is plain data, so a caller rewrites a parsed program (for example,
+  expanding predicate shorthand) before checking it.
+
+## Why synchronous
+
+The engine is a pure function of its inputs with no I/O, so it exposes plain synchronous calls rather
+than Effects; callers that need Effect wrap a call where it is used. This keeps the hot path (one
+evaluation per appended fact) free of fiber overhead and the package free of third-party runtime dependencies.

package/dist/lib/Ast.mjs

@@ -0,0 +1,72 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+//#region src/Ast.ts
+var Ast_exports = /* @__PURE__ */ __exportAll({
+	atom: () => atom,
+	constant: () => constant,
+	format: () => format,
+	formatAtom: () => formatAtom,
+	formatLiteral: () => formatLiteral,
+	formatRule: () => formatRule,
+	formatTerm: () => formatTerm,
+	formatValue: () => formatValue,
+	literalVariables: () => literalVariables,
+	variable: () => variable,
+	variablesOf: () => variablesOf
+});
+/** Creates a variable term. */
+var variable = (name) => ({
+	type: "variable",
+	name
+});
+/** Creates a constant term. */
+var constant = (value) => ({
+	type: "constant",
+	value
+});
+/** Creates an atom. */
+var atom = (predicate, terms) => ({
+	predicate,
+	terms
+});
+/** Named (non-anonymous) variables of a term list, in order of first occurrence. */
+var variablesOf = (terms) => {
+	const names = [];
+	for (const term of terms) if (term.type === "variable" && !term.anonymous && !names.includes(term.name)) names.push(term.name);
+	return names;
+};
+/** Named variables a literal mentions, including those inside an aggregate body. */
+var literalVariables = (literal) => {
+	switch (literal.type) {
+		case "atom": return variablesOf(literal.atom.terms);
+		case "comparison": return variablesOf([literal.left, literal.right]);
+		case "aggregate": {
+			const terms = [literal.result, ...literal.target ? [literal.target] : []];
+			return [.../* @__PURE__ */ new Set([...variablesOf(terms), ...literal.body.flatMap(literalVariables)])];
+		}
+	}
+};
+/** Formats a value as dialect source. */
+var formatValue = (value) => typeof value === "number" ? String(value) : /^[a-z][A-Za-z0-9_]*$/.test(value) ? value : JSON.stringify(value);
+/** Formats a term as dialect source. */
+var formatTerm = (term) => term.type === "constant" ? formatValue(term.value) : term.anonymous ? "_" : term.name;
+/** Formats an atom as dialect source. */
+var formatAtom = (atom) => atom.terms.length === 0 ? atom.predicate : `${atom.predicate}(${atom.terms.map(formatTerm).join(", ")})`;
+/** Formats a literal as dialect source. */
+var formatLiteral = (literal) => {
+	switch (literal.type) {
+		case "atom": return `${literal.negated ? "not " : ""}${formatAtom(literal.atom)}`;
+		case "comparison": return `${formatTerm(literal.left)} ${literal.operator} ${formatTerm(literal.right)}`;
+		case "aggregate": {
+			const target = literal.target ? ` ${formatTerm(literal.target)}` : "";
+			return `${formatTerm(literal.result)} = ${literal.function}${target} : { ${literal.body.map(formatLiteral).join(", ")} }`;
+		}
+	}
+};
+/** Formats a rule as dialect source. */
+var formatRule = (rule) => rule.body.length === 0 ? `${formatAtom(rule.head)}.` : `${formatAtom(rule.head)} :- ${rule.body.map(formatLiteral).join(", ")}.`;
+/** Formats a program as dialect source, one rule per line. */
+var format = (program) => program.rules.map(formatRule).join("\n");
+//#endregion
+export { atom, constant, format, formatAtom, formatLiteral, formatRule, formatTerm, formatValue, literalVariables, Ast_exports as t, variable, variablesOf };
+
+//# sourceMappingURL=Ast.mjs.map

package/dist/lib/Ast.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ast.mjs","names":[],"sources":["../../src/Ast.ts"],"sourcesContent":["//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\n/** A ground value; symbols (`dima`) and strings (`\"dima\"`) are the same value. */\nexport type Value = string | number;\n\n/** A ground row of a relation. */\nexport type Tuple = ReadonlyArray<Value>;\n\n/** Source location (1-based line and column). */\nexport type Position = { readonly line: number; readonly column: number };\n\nexport type Variable = {\n  readonly type: 'variable';\n  readonly name: string;\n  /** Set for `_`; each occurrence is a distinct, never-joined variable. */\n  readonly anonymous?: boolean;\n};\n\nexport type Constant = { readonly type: 'constant'; readonly value: Value };\n\nexport type Term = Variable | Constant;\n\nexport type Atom = { readonly predicate: string; readonly terms: ReadonlyArray<Term> };\n\nexport type ComparisonOperator = '=' | '!=' | '<' | '<=' | '>' | '>=';\n\nexport type AggregateFunction = 'count' | 'min' | 'max' | 'sum';\n\nexport type AtomLiteral = {\n  readonly type: 'atom';\n  readonly atom: Atom;\n  readonly negated: boolean;\n  readonly position?: Position;\n};\n\nexport type ComparisonLiteral = {\n  readonly type: 'comparison';\n  readonly operator: ComparisonOperator;\n  readonly left: Term;\n  readonly right: Term;\n  readonly position?: Position;\n};\n\n/** `Result = fn Target : { body }`; `Target` is absent for `count`. */\nexport type AggregateLiteral = {\n  readonly type: 'aggregate';\n  readonly function: AggregateFunction;\n  readonly result: Term;\n  readonly target?: Term;\n  readonly body: ReadonlyArray<Literal>;\n  readonly position?: Position;\n};\n\nexport type Literal = AtomLiteral | ComparisonLiteral | AggregateLiteral;\n\n/** A rule; a fact is a rule with an empty body. */\nexport type Rule = {\n  readonly head: Atom;\n  readonly body: ReadonlyArray<Literal>;\n  readonly position?: Position;\n};\n\nexport type Program = { readonly rules: ReadonlyArray<Rule> };\n\n/** Creates a variable term. */\nexport const variable = (name: string): Variable => ({ type: 'variable', name });\n\n/** Creates a constant term. */\nexport const constant = (value: Value): Constant => ({ type: 'constant', value });\n\n/** Creates an atom. */\nexport const atom = (predicate: string, terms: ReadonlyArray<Term>): Atom => ({ predicate, terms });\n\n/** Named (non-anonymous) variables of a term list, in order of first occurrence. */\nexport const variablesOf = (terms: ReadonlyArray<Term>): string[] => {\n  const names: string[] = [];\n  for (const term of terms) {\n    if (term.type === 'variable' && !term.anonymous && !names.includes(term.name)) {\n      names.push(term.name);\n    }\n  }\n  return names;\n};\n\n/** Named variables a literal mentions, including those inside an aggregate body. */\nexport const literalVariables = (literal: Literal): string[] => {\n  switch (literal.type) {\n    case 'atom':\n      return variablesOf(literal.atom.terms);\n    case 'comparison':\n      return variablesOf([literal.left, literal.right]);\n    case 'aggregate': {\n      const terms = [literal.result, ...(literal.target ? [literal.target] : [])];\n      return [...new Set([...variablesOf(terms), ...literal.body.flatMap(literalVariables)])];\n    }\n  }\n};\n\n/** Formats a value as dialect source. */\nexport const formatValue = (value: Value): string =>\n  typeof value === 'number' ? String(value) : /^[a-z][A-Za-z0-9_]*$/.test(value) ? value : JSON.stringify(value);\n\n/** Formats a term as dialect source. */\nexport const formatTerm = (term: Term): string =>\n  term.type === 'constant' ? formatValue(term.value) : term.anonymous ? '_' : term.name;\n\n/** Formats an atom as dialect source. */\nexport const formatAtom = (atom: Atom): string =>\n  atom.terms.length === 0 ? atom.predicate : `${atom.predicate}(${atom.terms.map(formatTerm).join(', ')})`;\n\n/** Formats a literal as dialect source. */\nexport const formatLiteral = (literal: Literal): string => {\n  switch (literal.type) {\n    case 'atom':\n      return `${literal.negated ? 'not ' : ''}${formatAtom(literal.atom)}`;\n    case 'comparison':\n      return `${formatTerm(literal.left)} ${literal.operator} ${formatTerm(literal.right)}`;\n    case 'aggregate': {\n      const target = literal.target ? ` ${formatTerm(literal.target)}` : '';\n      return `${formatTerm(literal.result)} = ${literal.function}${target} : { ${literal.body.map(formatLiteral).join(', ')} }`;\n    }\n  }\n};\n\n/** Formats a rule as dialect source. */\nexport const formatRule = (rule: Rule): string =>\n  rule.body.length === 0\n    ? `${formatAtom(rule.head)}.`\n    : `${formatAtom(rule.head)} :- ${rule.body.map(formatLiteral).join(', ')}.`;\n\n/** Formats a program as dialect source, one rule per line. */\nexport const format = (program: Program): string => program.rules.map(formatRule).join('\\n');\n"],"mappings":";;;;;;;;;;;;;;;;AAqEA,IAAa,YAAY,UAA4B;CAAE,MAAM;CAAY;AAAK;;AAG9E,IAAa,YAAY,WAA4B;CAAE,MAAM;CAAY;AAAM;;AAG/E,IAAa,QAAQ,WAAmB,WAAsC;CAAE;CAAW;AAAM;;AAGjG,IAAa,eAAe,UAAyC;CACnE,MAAM,QAAkB,CAAC;CACzB,KAAK,MAAM,QAAQ,OACjB,IAAI,KAAK,SAAS,cAAc,CAAC,KAAK,aAAa,CAAC,MAAM,SAAS,KAAK,IAAI,GAC1E,MAAM,KAAK,KAAK,IAAI;CAGxB,OAAO;AACT;;AAGA,IAAa,oBAAoB,YAA+B;CAC9D,QAAQ,QAAQ,MAAhB;EACE,KAAK,QACH,OAAO,YAAY,QAAQ,KAAK,KAAK;EACvC,KAAK,cACH,OAAO,YAAY,CAAC,QAAQ,MAAM,QAAQ,KAAK,CAAC;EAClD,KAAK,aAAa;GAChB,MAAM,QAAQ,CAAC,QAAQ,QAAQ,GAAI,QAAQ,SAAS,CAAC,QAAQ,MAAM,IAAI,CAAC,CAAE;GAC1E,OAAO,CAAC,mBAAG,IAAI,IAAI,CAAC,GAAG,YAAY,KAAK,GAAG,GAAG,QAAQ,KAAK,QAAQ,gBAAgB,CAAC,CAAC,CAAC;EACxF;CACF;AACF;;AAGA,IAAa,eAAe,UAC1B,OAAO,UAAU,WAAW,OAAO,KAAK,IAAI,uBAAuB,KAAK,KAAK,IAAI,QAAQ,KAAK,UAAU,KAAK;;AAG/G,IAAa,cAAc,SACzB,KAAK,SAAS,aAAa,YAAY,KAAK,KAAK,IAAI,KAAK,YAAY,MAAM,KAAK;;AAGnF,IAAa,cAAc,SACzB,KAAK,MAAM,WAAW,IAAI,KAAK,YAAY,GAAG,KAAK,UAAU,GAAG,KAAK,MAAM,IAAI,UAAU,CAAC,CAAC,KAAK,IAAI,EAAE;;AAGxG,IAAa,iBAAiB,YAA6B;CACzD,QAAQ,QAAQ,MAAhB;EACE,KAAK,QACH,OAAO,GAAG,QAAQ,UAAU,SAAS,KAAK,WAAW,QAAQ,IAAI;EACnE,KAAK,cACH,OAAO,GAAG,WAAW,QAAQ,IAAI,EAAE,GAAG,QAAQ,SAAS,GAAG,WAAW,QAAQ,KAAK;EACpF,KAAK,aAAa;GAChB,MAAM,SAAS,QAAQ,SAAS,IAAI,WAAW,QAAQ,MAAM,MAAM;GACnE,OAAO,GAAG,WAAW,QAAQ,MAAM,EAAE,KAAK,QAAQ,WAAW,OAAO,OAAO,QAAQ,KAAK,IAAI,aAAa,CAAC,CAAC,KAAK,IAAI,EAAE;EACxH;CACF;AACF;;AAGA,IAAa,cAAc,SACzB,KAAK,KAAK,WAAW,IACjB,GAAG,WAAW,KAAK,IAAI,EAAE,KACzB,GAAG,WAAW,KAAK,IAAI,EAAE,MAAM,KAAK,KAAK,IAAI,aAAa,CAAC,CAAC,KAAK,IAAI,EAAE;;AAG7E,IAAa,UAAU,YAA6B,QAAQ,MAAM,IAAI,UAAU,CAAC,CAAC,KAAK,IAAI"}

package/dist/lib/Builtin.mjs

@@ -0,0 +1,37 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+//#region src/Builtin.ts
+var Builtin_exports = /* @__PURE__ */ __exportAll({
+	acceptsBinding: () => acceptsBinding,
+	make: () => make,
+	predicate: () => predicate,
+	registry: () => registry
+});
+/** Defines a built-in. */
+var make = (builtin) => builtin;
+/** Defines a test-only built-in: holds iff `test` returns true for its fully bound arguments. */
+var predicate = (name, arity, test, options = {}) => ({
+	name,
+	arity,
+	modes: ["b".repeat(arity)],
+	volatile: options.volatile,
+	evaluate: (args) => {
+		const bound = args.filter((arg) => arg !== void 0);
+		return bound.length === arity && test(bound) ? [bound] : [];
+	}
+});
+/** Builds a registry, rejecting duplicate names. */
+var registry = (...builtins) => {
+	const entries = /* @__PURE__ */ new Map();
+	for (const builtin of builtins) {
+		if (entries.has(builtin.name)) throw new Error(`Duplicate built-in: ${builtin.name}`);
+		if (builtin.modes.some((mode) => mode.length !== builtin.arity || /[^bf]/.test(mode))) throw new Error(`Invalid mode for built-in ${builtin.name}/${builtin.arity}`);
+		entries.set(builtin.name, builtin);
+	}
+	return entries;
+};
+/** True if `builtin` can be called with exactly the `bound` argument positions bound. */
+var acceptsBinding = (builtin, bound) => bound.every(Boolean) || builtin.modes.some((mode) => [...mode].every((flag, index) => flag === "f" || bound[index]));
+//#endregion
+export { acceptsBinding, make, predicate, registry, Builtin_exports as t };
+
+//# sourceMappingURL=Builtin.mjs.map

package/dist/lib/Builtin.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Builtin.mjs","names":[],"sources":["../../src/Builtin.ts"],"sourcesContent":["//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\nimport type * as Ast from './Ast.ts';\n\n/**\n * A binding pattern, one character per argument: `b` must be bound before the call, `f` may be\n * free and is bound by the call. `\"fb\"` lets the first argument be generated from the second.\n */\nexport type Mode = string;\n\n/** Arguments as seen by a built-in: `undefined` marks a free position of the selected mode. */\nexport type Arguments = ReadonlyArray<Ast.Value | undefined>;\n\n/** A predicate implemented in code rather than by rules. */\nexport type Builtin = {\n  readonly name: string;\n  readonly arity: number;\n  /** Accepted binding patterns; the all-bound pattern is always accepted. */\n  readonly modes: ReadonlyArray<Mode>;\n  /**\n   * Set when the result can change with no change to the facts (a clock), so the engine\n   * re-evaluates the rules that use it on `refresh`.\n   */\n  readonly volatile?: boolean;\n  /** Returns every full argument tuple that holds and agrees with the bound arguments. */\n  readonly evaluate: (args: Arguments) => Iterable<Ast.Tuple>;\n};\n\n/** Built-ins by name. */\nexport type Registry = ReadonlyMap<string, Builtin>;\n\n/** Defines a built-in. */\nexport const make = (builtin: Builtin): Builtin => builtin;\n\n/** Defines a test-only built-in: holds iff `test` returns true for its fully bound arguments. */\nexport const predicate = (\n  name: string,\n  arity: number,\n  test: (args: Ast.Tuple) => boolean,\n  options: { volatile?: boolean } = {},\n): Builtin => ({\n  name,\n  arity,\n  modes: ['b'.repeat(arity)],\n  volatile: options.volatile,\n  evaluate: (args) => {\n    const bound = args.filter((arg): arg is Ast.Value => arg !== undefined);\n    return bound.length === arity && test(bound) ? [bound] : [];\n  },\n});\n\n/** Builds a registry, rejecting duplicate names. */\nexport const registry = (...builtins: ReadonlyArray<Builtin>): Registry => {\n  const entries = new Map<string, Builtin>();\n  for (const builtin of builtins) {\n    if (entries.has(builtin.name)) {\n      throw new Error(`Duplicate built-in: ${builtin.name}`);\n    }\n    if (builtin.modes.some((mode) => mode.length !== builtin.arity || /[^bf]/.test(mode))) {\n      throw new Error(`Invalid mode for built-in ${builtin.name}/${builtin.arity}`);\n    }\n    entries.set(builtin.name, builtin);\n  }\n  return entries;\n};\n\n/** True if `builtin` can be called with exactly the `bound` argument positions bound. */\nexport const acceptsBinding = (builtin: Builtin, bound: ReadonlyArray<boolean>): boolean =>\n  bound.every(Boolean) || builtin.modes.some((mode) => [...mode].every((flag, index) => flag === 'f' || bound[index]));\n"],"mappings":";;;;;;;;;AAoCA,IAAa,QAAQ,YAA8B;;AAGnD,IAAa,aACX,MACA,OACA,MACA,UAAkC,CAAC,OACtB;CACb;CACA;CACA,OAAO,CAAC,IAAI,OAAO,KAAK,CAAC;CACzB,UAAU,QAAQ;CAClB,WAAW,SAAS;EAClB,MAAM,QAAQ,KAAK,QAAQ,QAA0B,QAAQ,KAAA,CAAS;EACtE,OAAO,MAAM,WAAW,SAAS,KAAK,KAAK,IAAI,CAAC,KAAK,IAAI,CAAC;CAC5D;AACF;;AAGA,IAAa,YAAY,GAAG,aAA+C;CACzE,MAAM,0BAAU,IAAI,IAAqB;CACzC,KAAK,MAAM,WAAW,UAAU;EAC9B,IAAI,QAAQ,IAAI,QAAQ,IAAI,GAC1B,MAAM,IAAI,MAAM,uBAAuB,QAAQ,MAAM;EAEvD,IAAI,QAAQ,MAAM,MAAM,SAAS,KAAK,WAAW,QAAQ,SAAS,QAAQ,KAAK,IAAI,CAAC,GAClF,MAAM,IAAI,MAAM,6BAA6B,QAAQ,KAAK,GAAG,QAAQ,OAAO;EAE9E,QAAQ,IAAI,QAAQ,MAAM,OAAO;CACnC;CACA,OAAO;AACT;;AAGA,IAAa,kBAAkB,SAAkB,UAC/C,MAAM,MAAM,OAAO,KAAK,QAAQ,MAAM,MAAM,SAAS,CAAC,GAAG,IAAI,CAAC,CAAC,OAAO,MAAM,UAAU,SAAS,OAAO,MAAM,MAAM,CAAC"}

package/dist/lib/Checker.mjs

@@ -0,0 +1,3 @@
+import "./Ast.mjs";
+import { i as formatDiagnostic, r as check, t as CheckError } from "./chunk-Checker.mjs";
+export { CheckError, check, formatDiagnostic };

package/dist/lib/Engine.mjs

@@ -0,0 +1,3 @@
+import "./Ast.mjs";
+import { r as make, t as Engine } from "./chunk-Engine.mjs";
+export { Engine, make };

package/dist/lib/Parser.mjs

@@ -0,0 +1,2 @@
+import { r as parse, t as ParseError } from "./chunk-Parser.mjs";
+export { ParseError, parse };