@bjornpagen/bumbledb 1.1.0 → 1.2.1

package/dist/query/lower.js

@@ -1,13 +1,15 @@
-import { sealedFieldsOf } from "#closed.ts";
+import { membersAgree, sealedFieldsOf } from "#closed.ts";
 import { AuthoringError, SdkInvariantError } from "#errors.ts";
-import { assertDeclarationOrderKey, f64 as f64Field, isFloatIntervalValue, isIntervalValue, literalShapeError, rosterOf, u64 as u64Field } from "#fields.ts";
+import { assertDeclarationOrderKey, f64 as f64Field, i64 as i64Field, isFloatIntervalValue, isIntervalValue, literalShapeError, rosterOf, rostersAgree, u64 as u64Field } from "#fields.ts";
+import { snapshotData } from "#immutable.ts";
 import { allen, and, eq, ge, gt, le, lt, ne, not, or, pointIn } from "#query/atom.ts";
 import { computeFieldOf, computeVarsOf, isComputeExpr, MAX_COMPUTE_DEPTH } from "#query/compute.ts";
 import { count, max, mean, min, pack, sum } from "#query/find.ts";
 import { parseQueryIr } from "#query/parse-ir.ts";
 import { fieldAntiJoins, fieldJoins, headFieldJoins, importFacadeOf, importFacadeOfOwner, inferred, isImportedSource, isTerm, labelImport, makeParam, makeSetParam, renderFieldKind, term } from "#query/scope.ts";
 import { literalWireOf } from "#scalar.ts";
-import { Uuid } from "#uuid.ts";
+import { schemaDescriptor, schemasAgree } from "#schema.ts";
+import { arrayValue, recordValue, taggedValueOf } from "#values.ts";
 const termOps = Object.freeze({
     param: makeParam,
     inSet: makeSetParam,
@@ -36,8 +38,8 @@ const EMPTY_RULE = Object.freeze({
 });
 /**
  * The MINT slot of a variable, the runtime twin of {@link MintSlotOf}: (i)
- * verifies the mint owner is the schema's own member value — a variable
- * minted from a foreign relation is refused, naming its label — and (ii)
+ * verifies the mint owner agrees with the schema's ordered declaration — a
+ * conflicting declaration is refused, naming its label — and (ii)
  * returns the descriptor it was minted at plus the law-computed class read
  * off the schema's frozen class map. Because {@link fieldJoins} is an
  * equality, judging every binding position against this one slot makes all
@@ -50,16 +52,16 @@ function mintSlotOf(context, ref) {
         // the descriptor it projected and the carrier class that survived
         // the projection (aggregate outputs are bare derived scalars).
         const column = facade.columns.get(ref.column);
-        if (column === undefined || facade.source.schema !== context.theory) {
+        if (column === undefined || !schemasAgree(facade.source.schema, context.theory)) {
             throw new AuthoringError({
                 message: `the variable ${ref.label} was minted from a query template schema ${context.theory.name} does not own`
             });
         }
         return column.slot ?? { field: ref.field, class: undefined };
     }
-    if (context.theory.relations[ref.owner.name] !== ref.owner) {
+    if (!membersAgree(context.theory.relations[ref.owner.name], ref.owner)) {
         throw new AuthoringError({
-            message: `the variable ${ref.label} was minted from a relation schema ${context.theory.name} does not declare — mint variables with v() from the schema's own relations`
+            message: `the variable ${ref.label} was minted from a relation schema ${context.theory.name} does not declare — use an equivalent ordered declaration`
         });
     }
     return { field: ref.field, class: context.classes[ref.owner.name]?.[ref.column] };
@@ -82,7 +84,7 @@ function membershipSet(context, field, value) {
         });
     }
     const seen = new Set();
-    const members = value.map(function memberName(member) {
+    const members = arrayValue(context, value, function memberName(context, member) {
         if (typeof member !== "string") {
             throw literalShapeError(context, `a ${roster.name} handle name (string)`, member);
         }
@@ -97,16 +99,23 @@ function membershipSet(context, field, value) {
     const key = [...members].sort();
     return { name: `∈ ${roster.name} ${JSON.stringify(key)}`, members: Object.freeze(members) };
 }
-function resolveBindings(context, label, relation, bindings, joins = fieldJoins) {
+function queryRecord(context, input) {
+    return recordValue(context, input, typeof input === "object" && input !== null ? Object.keys(input) : []);
+}
+function resolveBindings(context, label, input, bindings, joins = fieldJoins) {
+    const relation = context.theory.relations[input.name];
+    if (relation === undefined || !membersAgree(relation, input)) {
+        throw new AuthoringError({
+            message: `${label}: schema ${context.theory.name} does not declare this ordered relation`
+        });
+    }
+    // Retain the schema-owned declaration, not mutable caller metadata.
     const entries = [];
     const vars = [];
     const uses = [];
     const relationClasses = context.classes[relation.name];
     const ordered = sealedFieldsOf(relation);
-    for (const [fieldName, value] of Object.entries(bindings)) {
-        if (value === undefined) {
-            continue;
-        }
+    for (const [fieldName, value] of Object.entries(queryRecord(label, bindings))) {
         const declared = ordered.find(function byName(candidate) {
             return candidate.name === fieldName;
         });
@@ -166,7 +175,10 @@ function resolveBindings(context, label, relation, bindings, joins = fieldJoins)
             }));
         }
         else {
-            bound = Object.freeze({ kind: "literal", value });
+            bound = Object.freeze({
+                kind: "literal",
+                value: ownLiteral(`${label}.${fieldName}`, declared.field, value, "binding")
+            });
         }
         entries.push(Object.freeze({ field: fieldName, data: declared.field, class: fieldClass, term: bound }));
     }
@@ -211,9 +223,22 @@ function sideUses(op, side, sibling, uses) {
     }));
 }
 function condDataOf(cond, uses) {
+    queryRecord("query condition", cond);
     if (cond.cond === "cmp") {
-        const lhs = cmpTermDataOf(cond.lhs);
-        const rhs = cmpTermDataOf(cond.rhs);
+        let lhs = cmpTermDataOf(cond.lhs);
+        let rhs = cmpTermDataOf(cond.rhs);
+        if (lhs.kind === "literal" && rhs.kind === "var") {
+            lhs = Object.freeze({
+                kind: "literal",
+                value: ownLiteral("comparison literal", rhs.ref.field, lhs.value, cond.op)
+            });
+        }
+        if (rhs.kind === "literal" && lhs.kind === "var") {
+            rhs = Object.freeze({
+                kind: "literal",
+                value: ownLiteral("comparison literal", lhs.ref.field, rhs.value, cond.op)
+            });
+        }
         sideUses(cond.op, lhs, rhs, uses);
         sideUses(cond.op, rhs, lhs, uses);
         if (cond.op === "allen") {
@@ -233,7 +258,7 @@ function condDataOf(cond, uses) {
         return Object.freeze({ kind: "cmp", op: { kind: cond.op }, lhs, rhs });
     }
     if (cond.cond === "tree") {
-        const children = cond.children.map(function lowerChild(child) {
+        const children = arrayValue("query condition children", cond.children, function lowerChild(_context, child) {
             return condDataOf(child, uses);
         });
         return Object.freeze({ kind: "tree", op: cond.op, children: Object.freeze(children) });
@@ -243,21 +268,16 @@ function condDataOf(cond, uses) {
     });
 }
 function advanceWhere(context, state, cond) {
+    queryRecord("query condition", cond);
     if (typeof cond !== "object" || cond === null || !("cond" in cond)) {
         throw new AuthoringError({ message: "where() takes a comparison, an and()/or() tree, or a negated atom" });
     }
     if (cond.cond === "notInterior") {
-        const bindings = Object.fromEntries(Object.entries(cond.bindings ?? {}).filter(function defined([, value]) {
-            return value !== undefined;
-        }));
-        return notInteriorAdvance(context, state, cond.name, bindings);
+        return notInteriorAdvance(context, state, cond.name, queryRecord("negated interior bindings", cond.bindings));
     }
     if (cond.cond === "not") {
         const relation = cond.relation;
-        const bindings = Object.fromEntries(Object.entries(cond.bindings ?? {}).filter(function defined([, value]) {
-            return value !== undefined;
-        }));
-        const resolved = resolveBindings(context, `negated relation ${relation.name}`, relation, bindings, fieldAntiJoins);
+        const resolved = resolveBindings(context, `negated relation ${relation.name}`, relation, cond.bindings, fieldAntiJoins);
         return Object.freeze({
             items: Object.freeze([...state.items, Object.freeze({ kind: "negated", atom: resolved.atom })]),
             bound: state.bound,
@@ -274,10 +294,7 @@ function advanceWhere(context, state, cond) {
 }
 function advanceInterior(state, target, bindings, kind) {
     const resolved = [];
-    for (const [key, value] of Object.entries(bindings)) {
-        if (value === undefined) {
-            continue;
-        }
+    for (const [key, value] of Object.entries(queryRecord(`interior ${target.name} bindings`, bindings))) {
         if (!isTerm(value) || value[term] !== "var") {
             throw new AuthoringError({
                 message: `interior ${target.name}: position ${key} takes a variable — bind literals and params through where()/match()`
@@ -621,27 +638,42 @@ function interiorAdvance(context, state, name, bindings) {
 }
 const importEntries = new WeakMap();
 const importTables = new WeakSet();
+const importOrigins = new WeakMap();
+function snapshotQueryData(input) {
+    return snapshotData(input, (source, snapshot) => {
+        // Detached imports retain their authoring identity for deduplication.
+        if (importTables.has(source)) {
+            const table = snapshot;
+            importTables.add(table);
+            importOrigins.set(table, importOrigins.get(source) ?? source);
+            const inner = importInner.get(source);
+            if (inner !== undefined)
+                importInner.set(table, inner);
+        }
+    });
+}
 function importEntryOf(context, imported) {
     const cached = importEntries.get(imported);
     if (cached !== undefined) {
-        if (imported.schema !== context.theory) {
+        if (!schemasAgree(imported.schema, context.theory)) {
             throw new AuthoringError({
                 message: `${contextLabel(context)}: the imported query belongs to schema ${imported.schema.name}, not ${context.theory.name} — templates compose within one schema`
             });
         }
         return cached;
     }
-    if (imported.schema !== context.theory) {
+    if (!schemasAgree(imported.schema, context.theory)) {
         throw new AuthoringError({
             message: `${contextLabel(context)}: the imported query belongs to schema ${imported.schema.name}, not ${context.theory.name} — templates compose within one schema`
         });
     }
-    if (imported.data.kind === "reach") {
+    const data = imported.data;
+    if (data.kind === "reach") {
         throw new AuthoringError({
             message: `${contextLabel(context)}: a recursive query is not importable as a relation expression yet — declare the recursion on the consuming query (C05 boundary, recorded)`
         });
     }
-    const userParams = imported.data.params.filter(function userSupplied(entry) {
+    const userParams = data.params.filter(function userSupplied(entry) {
         return entry.membership === undefined;
     });
     if (userParams.length > 0) {
@@ -654,10 +686,10 @@ function importEntryOf(context, imported) {
     const facade = importFacadeOf(imported);
     const table = Object.freeze({
         name: facade.owner.name,
-        finds: imported.data.finds,
-        rules: imported.data.rules
+        finds: data.finds,
+        rules: data.rules
     });
-    const entry = Object.freeze({ table, inner: imported.data.interiors });
+    const entry = Object.freeze({ table, inner: data.interiors });
     importEntries.set(imported, entry);
     importTables.add(table);
     importInner.set(table, entry.inner);
@@ -679,8 +711,9 @@ function referencedImports(interiors, rec, rules) {
                     continue;
                 }
                 const target = item.target;
-                if (importTables.has(target) && !seen.has(target)) {
-                    seen.add(target);
+                const origin = importOrigins.get(target) ?? target;
+                if (importTables.has(target) && !seen.has(origin)) {
+                    seen.add(origin);
                     out.push(target);
                 }
             }
@@ -712,7 +745,8 @@ function spliceImports(interiors, rec, rules) {
     const names = new Set();
     const added = new Set();
     function add(table) {
-        if (added.has(table)) {
+        const origin = importOrigins.get(table) ?? table;
+        if (added.has(origin)) {
             return;
         }
         if (names.has(table.name)) {
@@ -720,7 +754,7 @@ function spliceImports(interiors, rec, rules) {
                 message: `query: the derived-table name ${table.name} appears twice after import splicing — rename the colliding interior (names are unique)`
             });
         }
-        added.add(table);
+        added.add(origin);
         names.add(table.name);
         spliced.push(table);
     }
@@ -749,15 +783,13 @@ function notInteriorAdvance(context, state, name, bindings) {
 }
 function findColumns(context, entries) {
     const columns = [];
+    queryRecord("query find", entries);
     // Nonrecursive derived stages (interiors) may emit aggregate/computed
     // outputs (C05: "do not leave Interior.rules projection only"); ONLY the
     // recursive feedback cycle stays projection-only — no aggregate,
     // arithmetic-created value or negation flows through it.
     const recName = context.kind === "rec-base" || context.kind === "rec-arm" ? context.self.name : undefined;
     for (const [name, entry] of Object.entries(entries)) {
-        if (entry === undefined) {
-            continue;
-        }
         if (recName !== undefined && !(isTerm(entry) && entry[term] === "var")) {
             throw new AuthoringError({
                 message: `rec ${recName}: a rec head projects bound variables only — no aggregate or arithmetic-created value flows through the feedback cycle (compute over the finished set in the main rules)`
@@ -912,7 +944,7 @@ function paramRegistryOf(interiors, rec, rules) {
             if (existing.anchor !== undefined && use.anchor !== undefined) {
                 const registered = rosterOf(existing.anchor);
                 const anchored = rosterOf(use.anchor);
-                if (registered !== anchored) {
+                if (!rostersAgree(registered, anchored)) {
                     throw new AuthoringError({
                         message: `query param ${use.name} is anchored at ${renderParamAnchor(registered)} and at ${renderParamAnchor(anchored)} — a closed-anchored param translates handle names through ONE roster (one name, one domain); name the params differently`
                     });
@@ -984,7 +1016,7 @@ function alignedHeadOf(label, rules) {
         }
         rule.finds.forEach(function verifyClosedSlice(column, position) {
             const lead = first.finds[position];
-            if (lead !== undefined && column.closed !== lead.closed) {
+            if (lead !== undefined && !rostersAgree(column.closed, lead.closed)) {
                 throw new AuthoringError({
                     message: `every rule of ${label} derives the same head — the head column ${lead.name} is ${renderClosedSlice(lead.closed)} in rule 0 but ${renderClosedSlice(column.closed)} in rule ${index} (one column decodes through one roster)`
                 });
@@ -1025,7 +1057,13 @@ function afterMainError(what) {
         message: `query: ${what} after a main rule is unwritable — declaration order is interiors, then rec, then main`
     });
 }
-function makeRawQuery(theory, interiors, rec, rules) {
+function makeRawQuery(inputTheory, inputInteriors, inputRec, inputRules) {
+    const { theory, interiors, rec, rules } = snapshotQueryData({
+        theory: inputTheory,
+        interiors: inputInteriors,
+        rec: inputRec,
+        rules: inputRules
+    });
     const mergedFinds = alignedHeadOf("a query", rules);
     const first = rules[0];
     if (first === undefined) {
@@ -1053,8 +1091,12 @@ function makeRawQuery(theory, interiors, rec, rules) {
             params
         });
     const value = {
-        schema: theory,
-        data,
+        get schema() {
+            return snapshotData(theory);
+        },
+        get data() {
+            return snapshotQueryData(data);
+        },
         rule(build) {
             const built = build(makeRawScope({ kind: "query", classes: theory.classes, theory, ...env }));
             return makeRawQuery(theory, interiors, rec, [...rules, built.rule]);
@@ -1129,9 +1171,9 @@ function collectRec(theory, interiors, name, baseBuilds, recBuilds) {
     const sealedRec = [firstRec, ...rec.slice(1)];
     const recData = Object.freeze({
         name,
-        finds: sealedFinds,
-        base: sealedBase,
-        rec: sealedRec
+        finds: Object.freeze(sealedFinds),
+        base: Object.freeze(sealedBase),
+        rec: Object.freeze(sealedRec)
     });
     return recData;
 }
@@ -1164,7 +1206,9 @@ function makeQueryStart(theory, interiors) {
         },
         rule(build) {
             const built = build(makeQueryRuleScope(theory, env));
-            return makeQuery(theory, interiors, undefined, [built.rule]);
+            return makeQuery(theory, interiors, undefined, [
+                built.rule
+            ]);
         }
     };
     Object.freeze(start);
@@ -1175,112 +1219,27 @@ function makeQueryReachStart(theory, interiors, rec) {
     const start = {
         rule(build) {
             const built = build(makeQueryRuleScope(theory, env));
-            return makeQuery(theory, interiors, rec, [built.rule]);
+            return makeQuery(theory, interiors, rec, [
+                built.rule
+            ]);
         }
     };
     Object.freeze(start);
     return start;
 }
 function query(theory) {
-    return makeQueryStart(theory, []);
-}
-function taggedHandleId(context, closed, value) {
-    if (typeof value !== "string") {
-        throw literalShapeError(context, `a ${closed.name} handle name (string)`, value);
-    }
-    const id = closed.handles.indexOf(value);
-    if (id < 0) {
-        throw new AuthoringError({
-            message: `${context}: "${value}" is not a handle of ${closed.name} — the roster is ${closed.handles.join(", ")}`
-        });
-    }
-    return { kind: "u64", value: BigInt(id) };
+    return makeQueryStart(schemaDescriptor(theory), []);
 }
 function taggedAtElementDomain(context, element, value) {
-    if (element === "f64") {
-        if (typeof value === "number") {
-            return { kind: "f64", value };
-        }
-        if (isFloatIntervalValue(value)) {
-            if (Number.isNaN(value.start) || Number.isNaN(value.end) || !(value.start < value.end)) {
-                throw literalShapeError(context, "a nonempty float interval with non-NaN endpoints", value);
-            }
-            return {
-                kind: "intervalF64",
-                start: Object.is(value.start, -0) ? 0 : value.start,
-                end: Object.is(value.end, -0) ? 0 : value.end
-            };
-        }
-        throw literalShapeError(context, "number (point) or { start, end } numbers (interval)", value);
-    }
-    if (typeof value === "bigint") {
-        if (element === "u64") {
-            return { kind: "u64", value };
-        }
-        return { kind: "i64", value };
-    }
-    if (isIntervalValue(value)) {
-        if (element === "u64") {
-            return { kind: "intervalU64", start: value.start, end: value.end };
-        }
-        return { kind: "intervalI64", start: value.start, end: value.end };
-    }
-    throw literalShapeError(context, "bigint (point) or { start, end } (interval)", value);
+    const field = typeof value === "number" || typeof value === "bigint"
+        ? { u64: u64Field, i64: i64Field, f64: f64Field }[element]
+        : { kind: "interval", element, width: undefined };
+    return taggedValueOf(context, field, value);
 }
 function taggedLiteral(context, field, value) {
-    const roster = rosterOf(field);
-    if (roster !== undefined) {
-        return taggedHandleId(context, roster, value);
-    }
-    switch (field.kind) {
-        case "bool": {
-            if (typeof value !== "boolean") {
-                throw literalShapeError(context, "boolean", value);
-            }
-            return { kind: "bool", value };
-        }
-        case "u64": {
-            if (typeof value !== "bigint") {
-                throw literalShapeError(context, "bigint", value);
-            }
-            return { kind: "u64", value };
-        }
-        case "i64": {
-            if (typeof value !== "bigint") {
-                throw literalShapeError(context, "bigint", value);
-            }
-            return { kind: "i64", value };
-        }
-        case "f64": {
-            if (typeof value !== "number") {
-                throw literalShapeError(context, "number", value);
-            }
-            return { kind: "f64", value };
-        }
-        case "uuid": {
-            if (!Uuid.isUuid(value)) {
-                throw literalShapeError(context, "a UUID (canonical UUID text)", value);
-            }
-            return { kind: "uuid", value };
-        }
-        case "str": {
-            if (typeof value !== "string") {
-                throw literalShapeError(context, "string", value);
-            }
-            if (!value.isWellFormed()) {
-                throw literalShapeError(context, "well-formed string", value);
-            }
-            return { kind: "string", value };
-        }
-        case "bytes": {
-            if (!(value instanceof Uint8Array)) {
-                throw literalShapeError(context, "Uint8Array", value);
-            }
-            return { kind: "fixedBytes", value };
-        }
-        case "interval":
-            return taggedAtElementDomain(context, field.element, value);
-    }
+    return field.kind === "interval"
+        ? taggedAtElementDomain(context, field.element, value)
+        : taggedValueOf(context, field, value);
 }
 /**
  * Tags one host literal at a COMPARISON or PARAM position, where the SIBLING
@@ -1288,7 +1247,7 @@ function taggedLiteral(context, field, value) {
  * contributes its element domain, a scalar sibling its own type. At
  * `pointIn` the operand order is interval-left, point-right, so an
  * interval-shaped literal beside a scalar element-typed sibling is the LEGAL
- * interval operand of `pointIn(t, span(...))`; under every other operator an
+ * interval operand of `pointIn(t, { start, end })`; under every other operator an
  * interval shape against a scalar sibling stays refused.
  */
 function taggedCmpLiteral(context, sibling, value, op) {
@@ -1306,6 +1265,15 @@ function taggedCmpLiteral(context, sibling, value, op) {
     }
     return taggedLiteral(context, sibling, value);
 }
+/** Validate and own a literal when the query is authored, before caller mutation. */
+function ownLiteral(context, field, value, op) {
+    const tagged = taggedCmpLiteral(context, field, value, op);
+    if (rosterOf(field) !== undefined)
+        return value;
+    if ("value" in tagged)
+        return tagged.value;
+    return Object.freeze({ start: tagged.start, end: tagged.end });
+}
 function freshVarIds() {
     const assigned = new Map();
     return {
@@ -1329,7 +1297,7 @@ function paramIdOf(ctx, name) {
 }
 function lowerAtom(ctx, atom, ids) {
     const member = ctx.theory.relations[atom.relation.name];
-    if (member !== atom.relation) {
+    if (!membersAgree(member, atom.relation)) {
         throw new AuthoringError({
             message: `query lowering: relation ${atom.relation.name} is not the relation value schema ${ctx.theory.name} declares`
         });
@@ -1563,20 +1531,21 @@ function lowerRule(ctx, rule) {
 }
 function lowerQuery(q) {
     const theory = q.schema;
+    const data = q.data;
     const relationIds = new Map();
     Object.keys(theory.relations).forEach(function assignOrdinal(name, index) {
         relationIds.set(name, index);
     });
     const interiorIds = new Map();
-    q.data.interiors.forEach(function assignInteriorId(interior, index) {
+    data.interiors.forEach(function assignInteriorId(interior, index) {
         interiorIds.set(interior.name, index);
     });
-    if (q.data.kind === "reach") {
-        interiorIds.set(q.data.rec.name, q.data.interiors.length);
+    if (data.kind === "reach") {
+        interiorIds.set(data.rec.name, data.interiors.length);
     }
     const paramIds = new Map();
     const params = new Map();
-    q.data.params.forEach(function assignParamId(entry, index) {
+    data.params.forEach(function assignParamId(entry, index) {
         if (entry.anchor === undefined) {
             throw new AuthoringError({
                 message: `query param ${entry.name} has no field-anchored use — bind it in an atom or compare it against a bound variable`
@@ -1586,7 +1555,7 @@ function lowerQuery(q) {
         params.set(entry.name, entry);
     });
     const ctx = { theory, relationIds, interiorIds, paramIds, params };
-    const interiors = q.data.interiors.map(function lowerInterior(interior) {
+    const interiors = data.interiors.map(function lowerInterior(interior) {
         return {
             head: interior.finds.map(headTermOf),
             rules: interior.rules.map(function lowerInteriorRule(rule) {
@@ -1594,22 +1563,22 @@ function lowerQuery(q) {
             })
         };
     });
-    const head = q.data.finds.map(headTermOf);
-    const rules = q.data.rules.map(function lowerMainRule(rule) {
+    const head = data.finds.map(headTermOf);
+    const rules = data.rules.map(function lowerMainRule(rule) {
         return lowerRule(ctx, rule);
     });
-    if (q.data.kind === "cq") {
+    if (data.kind === "cq") {
         return parseQueryIr({ kind: "cq", interiors, head, rules });
     }
     return parseQueryIr({
         kind: "reach",
         interiors,
         rec: {
-            head: q.data.rec.finds.map(headTermOf),
-            base: q.data.rec.base.map(function lowerBase(rule) {
+            head: data.rec.finds.map(headTermOf),
+            base: data.rec.base.map(function lowerBase(rule) {
                 return lowerRule(ctx, rule);
             }),
-            rec: q.data.rec.rec.map(function lowerRecArm(rule) {
+            rec: data.rec.rec.map(function lowerRecArm(rule) {
                 return lowerRule(ctx, rule);
             })
         },
@@ -1617,5 +1586,5 @@ function lowerQuery(q) {
         rules
     });
 }
-export { lowerQuery, query, taggedCmpLiteral };
+export { alignedHeadOf, EMPTY_RULE, lowerQuery, makeRawChain, makeRawQuery, query, taggedCmpLiteral };
 //# sourceMappingURL=lower.js.map