@bjornpagen/bumbledb 1.1.0 → 1.2.1

package/src/query/parse-ir.ts

@@ -1,75 +1,268 @@
 import { AuthoringError } from "#errors.ts"
-import type { FindTermIr, HeadTermIr, ParsedQuery, QueryIr, RuleIr } from "#native.ts"
+import type {
+	AtomIr,
+	CmpOpIr,
+	ConditionTreeIr,
+	FindTermIr,
+	HeadTermIr,
+	ParsedQuery,
+	QueryIr,
+	RuleIr,
+	ScalarExprIr,
+	TermIr
+} from "#native.ts"
+import { arrayValue as array, recordValue, valueDescriptor } from "#values.ts"
 
-function parseQueryIr(ir: QueryIr): ParsedQuery {
-	if (ir.rules.length === 0) {
-		throw new AuthoringError({ message: "parseQueryIr: main rules are empty" })
-	}
-	align("query", ir.head, ir.rules)
-	ir.interiors.forEach(function checkInterior(interior, index) {
-		align(`interior ${index}`, interior.head, interior.rules)
+function fail(context: string, expected: string): never {
+	throw new AuthoringError({
+		message: `${context}: ${expected}`,
+		diagnostic: { code: "InvalidQuery", context, expected }
 	})
-	if (ir.kind === "reach") {
-		if (ir.rec.base.length === 0) {
-			throw new AuthoringError({ message: "parseQueryIr: rec base is empty" })
-		}
-		if (ir.rec.rec.length === 0) {
-			throw new AuthoringError({ message: "parseQueryIr: rec step is empty" })
-		}
-		align("rec base", ir.rec.head, ir.rec.base)
-		align("rec step", ir.rec.head, ir.rec.rec)
+}
+
+function tagged(context: string, input: unknown): Readonly<Record<string, unknown>> {
+	if (typeof input !== "object" || input === null) return fail(context, "expected a descriptor record")
+	return recordValue(context, input, Object.keys(input))
+}
+
+function ordinal(context: string, input: unknown, maximum = 0xffff): number {
+	if (typeof input !== "number" || !Number.isInteger(input) || input < 0 || input > maximum)
+		return fail(context, `expected an ordinal from 0 through ${maximum}`)
+	return input
+}
+
+function term(context: string, input: unknown): TermIr {
+	const raw = tagged(context, input)
+	switch (raw.kind) {
+		case "var":
+			recordValue(context, raw, ["kind", "var"])
+			return Object.freeze({ kind: raw.kind, var: ordinal(context, raw.var) })
+		case "param":
+		case "paramSet":
+			recordValue(context, raw, ["kind", "param"])
+			return Object.freeze({ kind: raw.kind, param: ordinal(context, raw.param) })
+		case "literal":
+			recordValue(context, raw, ["kind", "value"])
+			return Object.freeze({ kind: raw.kind, value: valueDescriptor(`${context}.value`, raw.value) })
+		default:
+			return fail(context, "unknown term kind")
 	}
-	return ir as ParsedQuery
 }
 
-function align(context: string, head: readonly HeadTermIr[], rules: readonly RuleIr[]): void {
-	for (const [ruleIndex, rule] of rules.entries()) {
-		if (rule.finds.length !== head.length) {
-			throw new AuthoringError({
-				message: `${context}: rule ${ruleIndex} finds width ${rule.finds.length} does not match head width ${head.length}`
+function scalar(context: string, input: unknown, depth = 1): ScalarExprIr {
+	if (depth > 128) return fail(context, "scalar expression deeper than 128")
+	const raw = tagged(context, input)
+	switch (raw.kind) {
+		case "var":
+			recordValue(context, raw, ["kind", "var"])
+			return Object.freeze({ kind: raw.kind, var: ordinal(context, raw.var) })
+		case "literal":
+			recordValue(context, raw, ["kind", "value"])
+			return Object.freeze({ kind: raw.kind, value: valueDescriptor(`${context}.value`, raw.value) })
+		case "negate":
+		case "isNaN":
+		case "isFinite":
+			recordValue(context, raw, ["kind", "expr"])
+			return Object.freeze({ kind: raw.kind, expr: scalar(`${context}.expr`, raw.expr, depth + 1) })
+		case "add":
+		case "subtract":
+		case "multiply":
+		case "divide":
+			recordValue(context, raw, ["kind", "left", "right"])
+			return Object.freeze({
+				kind: raw.kind,
+				left: scalar(`${context}.left`, raw.left, depth + 1),
+				right: scalar(`${context}.right`, raw.right, depth + 1)
 			})
+		case "cast": {
+			recordValue(context, raw, ["kind", "cast", "expr"])
+			const cast = raw.cast
+			if (cast !== "toF64" && cast !== "toF64Exact" && cast !== "toI64Exact" && cast !== "toU64Exact")
+				return fail(context, "unknown numeric cast")
+			return Object.freeze({ kind: raw.kind, cast, expr: scalar(`${context}.expr`, raw.expr, depth + 1) })
 		}
-		rule.finds.forEach(function checkFind(find, position) {
-			parseFind(`${context} rule ${ruleIndex} find ${position}`, find)
-			const family = findFamily(find)
-			if (family !== head[position]?.kind) {
-				throw new AuthoringError({
-					message: `${context}: rule ${ruleIndex} find ${position} is ${family}, not head ${head[position]?.kind}`
-				})
-			}
-		})
+		default:
+			return fail(context, "unknown scalar expression kind")
 	}
 }
 
-function parseFind(context: string, find: FindTermIr): void {
-	const raw = find as Record<string, unknown>
-	if (find.kind === "count") {
-		if ("over" in raw) {
-			throw new AuthoringError({ message: `${context}: Count carries no over` })
-		}
-		return
-	}
-	if (find.kind === "pack" || find.kind === "aggregate") {
-		if (!("over" in raw)) {
-			throw new AuthoringError({ message: `${context}: ${find.kind} requires over` })
-		}
-	}
-	if (find.kind === "compute" && !("expr" in raw)) {
-		throw new AuthoringError({ message: `${context}: compute requires expr` })
+function headTerm(context: string, input: unknown): HeadTermIr {
+	const raw = tagged(context, input)
+	if (raw.kind === "var" || raw.kind === "compute") {
+		recordValue(context, raw, ["kind"])
+		return Object.freeze({ kind: raw.kind })
 	}
+	recordValue(context, raw, ["kind", "op"])
+	if (raw.kind !== "aggregate") return fail(context, "unknown head kind")
+	const op = raw.op
+	if (op !== "sum" && op !== "mean" && op !== "min" && op !== "max" && op !== "count" && op !== "pack")
+		return fail(context, "unknown head aggregate")
+	return Object.freeze({ kind: raw.kind, op })
 }
 
-function findFamily(find: FindTermIr): "var" | "aggregate" | "compute" {
-	switch (find.kind) {
+function find(context: string, input: unknown): FindTermIr {
+	const raw = tagged(context, input)
+	switch (raw.kind) {
 		case "var":
-			return "var"
-		case "compute":
-			return "compute"
+			recordValue(context, raw, ["kind", "var"])
+			return Object.freeze({ kind: raw.kind, var: ordinal(context, raw.var) })
 		case "count":
+			if (Object.hasOwn(raw, "over")) return fail(context, "Count carries no over")
+			recordValue(context, raw, ["kind"])
+			return Object.freeze({ kind: raw.kind })
+		case "compute":
+			if (!Object.hasOwn(raw, "expr")) return fail(context, "compute requires expr")
+			recordValue(context, raw, ["kind", "expr"])
+			return Object.freeze({ kind: raw.kind, expr: scalar(`${context}.expr`, raw.expr) })
 		case "pack":
-		case "aggregate":
-			return "aggregate"
+			recordValue(context, raw, ["kind", "over"])
+			return Object.freeze({ kind: raw.kind, over: ordinal(context, raw.over) })
+		case "aggregate": {
+			recordValue(context, raw, ["kind", "op", "over"])
+			const op = recordValue(`${context}.op`, raw.op, ["kind"]).kind
+			if (op !== "sum" && op !== "mean" && op !== "min" && op !== "max") return fail(context, "unknown fold operator")
+			return Object.freeze({ kind: raw.kind, op: Object.freeze({ kind: op }), over: ordinal(context, raw.over) })
+		}
+		default:
+			return fail(context, "unknown find kind")
+	}
+}
+
+function atom(context: string, input: unknown): AtomIr {
+	const raw = recordValue(context, input, ["source", "bindings"])
+	const source = tagged(`${context}.source`, raw.source)
+	let owned: AtomIr["source"]
+	if (source.kind === "edb") {
+		recordValue(context, source, ["kind", "relation"])
+		owned = { kind: source.kind, relation: ordinal(`${context}.source.relation`, source.relation, 0xffffffff) }
+	} else if (source.kind === "interior") {
+		recordValue(context, source, ["kind", "interior"])
+		owned = { kind: source.kind, interior: ordinal(`${context}.source.interior`, source.interior, 0xffffffff) }
+	} else return fail(context, "unknown atom source")
+	const seen = new Set<number>()
+	const bindings = array(`${context}.bindings`, raw.bindings, (path, pair): readonly [number, TermIr] => {
+		const cells = array(path, pair, (_, value) => value)
+		if (cells.length !== 2) return fail(path, "a binding has exactly two elements")
+		const field = ordinal(`${path}[0]`, cells[0])
+		if (seen.has(field)) return fail(path, "duplicate field binding")
+		seen.add(field)
+		return Object.freeze([field, term(`${path}[1]`, cells[1])])
+	})
+	return Object.freeze({ source: Object.freeze(owned), bindings })
+}
+
+function comparisonOp(context: string, input: unknown): CmpOpIr {
+	const raw = tagged(context, input)
+	if (raw.kind === "allen") {
+		recordValue(context, raw, ["kind", "mask"])
+		return Object.freeze({ kind: raw.kind, mask: ordinal(`${context}.mask`, raw.mask, 0x1fff) })
+	}
+	recordValue(context, raw, ["kind"])
+	const kind = raw.kind
+	if (
+		kind !== "eq" &&
+		kind !== "ne" &&
+		kind !== "lt" &&
+		kind !== "le" &&
+		kind !== "gt" &&
+		kind !== "ge" &&
+		kind !== "pointIn"
+	)
+		return fail(context, "unknown comparison operator")
+	return Object.freeze({ kind })
+}
+
+function condition(context: string, input: unknown, depth = 1): ConditionTreeIr {
+	if (depth > 64) return fail(context, "condition tree deeper than 64")
+	const raw = tagged(context, input)
+	if (raw.kind === "leaf") {
+		recordValue(context, raw, ["kind", "cmp"])
+		const cmp = recordValue(`${context}.cmp`, raw.cmp, ["op", "lhs", "rhs"])
+		return Object.freeze({
+			kind: raw.kind,
+			cmp: Object.freeze({
+				op: comparisonOp(`${context}.cmp.op`, cmp.op),
+				lhs: term(`${context}.cmp.lhs`, cmp.lhs),
+				rhs: term(`${context}.cmp.rhs`, cmp.rhs)
+			})
+		})
+	}
+	if (raw.kind !== "and" && raw.kind !== "or") return fail(context, "unknown condition kind")
+	recordValue(context, raw, ["kind", "children"])
+	return Object.freeze({
+		kind: raw.kind,
+		children: array(`${context}.children`, raw.children, (path, value) => condition(path, value, depth + 1))
+	})
+}
+
+function rule(context: string, input: unknown): RuleIr {
+	const raw = recordValue(context, input, ["finds", "atoms", "negated", "conditions"])
+	return Object.freeze({
+		finds: array(`${context}.finds`, raw.finds, find),
+		atoms: array(`${context}.atoms`, raw.atoms, atom),
+		negated: array(`${context}.negated`, raw.negated, atom),
+		conditions: array(`${context}.conditions`, raw.conditions, condition)
+	})
+}
+
+function align(context: string, head: readonly HeadTermIr[], rules: readonly RuleIr[]): void {
+	for (const [index, rule] of rules.entries()) {
+		if (rule.finds.length !== head.length) fail(`${context}.rules[${index}]`, "finds width does not match head width")
+		for (const [position, find] of rule.finds.entries()) {
+			const term = head[position]
+			const family = find.kind === "var" || find.kind === "compute" ? find.kind : "aggregate"
+			if (term?.kind !== family)
+				fail(`${context}.rules[${index}].finds[${position}]`, "find family does not match head")
+			if (term.kind === "aggregate") {
+				const op = find.kind === "aggregate" ? find.op.kind : find.kind
+				if (op !== term.op)
+					fail(`${context}.rules[${index}].finds[${position}]`, "aggregate operator does not match head")
+			}
+		}
+	}
+}
+
+/**
+ * Own and validate the complete wire grammar. The native compiler then
+ * checks schema membership, binding types, safety and recursion semantics;
+ * parsing alone does not assert that a query is admitted by a schema.
+ */
+function parseQueryIr(input: unknown): ParsedQuery {
+	const raw = tagged("query", input)
+	if (raw.kind !== "cq" && raw.kind !== "reach") return fail("query", "unknown query kind")
+	recordValue(
+		"query",
+		raw,
+		raw.kind === "cq" ? ["kind", "interiors", "head", "rules"] : ["kind", "interiors", "rec", "head", "rules"]
+	)
+	const rules = array("query.rules", raw.rules, rule)
+	if (rules.length === 0) return fail("parseQueryIr", "main rules are empty")
+	const head = array("query.head", raw.head, headTerm)
+	align("query", head, rules)
+	const interiors = array("query.interiors", raw.interiors, (path, input) => {
+		const raw = recordValue(path, input, ["head", "rules"])
+		const head = array(`${path}.head`, raw.head, headTerm)
+		const rules = array(`${path}.rules`, raw.rules, rule)
+		if (rules.length === 0) return fail(path, "interior rules are empty")
+		align(path, head, rules)
+		return Object.freeze({ head, rules })
+	})
+	let owned: QueryIr
+	if (raw.kind === "cq") owned = { kind: raw.kind, interiors, head, rules }
+	else {
+		const rawRec = recordValue("query.rec", raw.rec, ["head", "base", "rec"])
+		const headRec = array("query.rec.head", rawRec.head, headTerm)
+		const base = array("query.rec.base", rawRec.base, rule)
+		if (base.length === 0) return fail("parseQueryIr", "rec base is empty")
+		const rec = array("query.rec.rec", rawRec.rec, rule)
+		if (rec.length === 0) return fail("parseQueryIr", "rec step is empty")
+		align("rec base", headRec, base)
+		align("rec step", headRec, rec)
+		if (headRec.some((term) => term.kind !== "var") || [...base, ...rec].some((rule) => rule.negated.length !== 0))
+			return fail("query.rec", "recursion requires projection-only heads and no negation")
+		owned = { kind: raw.kind, interiors, head, rules, rec: Object.freeze({ head: headRec, base, rec }) }
 	}
+	return Object.freeze(owned) as ParsedQuery
 }
 
 export type { ParsedQuery }

package/src/query/run.ts

@@ -4,7 +4,8 @@ import type { FindColumn } from "#query/atom.ts"
 import { taggedCmpLiteral } from "#query/lower.ts"
 import type { ParamEntry } from "#query/scope.ts"
 import type { CellValue } from "#rows.ts"
-import { decodeCell, handleOf } from "#rows.ts"
+import { decodeCell, handleOf, setOwnField } from "#rows.ts"
+import { arrayValue, recordValue } from "#values.ts"
 
 function wireValue(entry: ParamEntry, context: string, value: unknown): TaggedValue {
 	if (entry.anchor === undefined) {
@@ -16,22 +17,24 @@ function wireValue(entry: ParamEntry, context: string, value: unknown): TaggedVa
 }
 
 function wireParams(entries: readonly ParamEntry[], supplied: Readonly<Record<string, unknown>>): QueryParam[] {
+	const input = recordValue(
+		"query parameters",
+		supplied,
+		entries.filter((entry) => entry.membership === undefined).map((entry) => entry.name)
+	)
 	return entries.map(function wireOne(entry): QueryParam {
 		if (entry.membership !== undefined) {
 			return entry.membership
 		}
-		const value = supplied[entry.name]
+		const value = input[entry.name]
 		if (value === undefined) {
 			throw new AuthoringError({ message: `execute params object is missing param ${entry.name}` })
 		}
 		if (entry.shape === "set") {
-			if (!Array.isArray(value)) {
-				throw new AuthoringError({ message: `param ${entry.name}: a set param binds a readonly array of values` })
-			}
 			return {
 				kind: "set",
-				values: value.map(function wireElement(element, index) {
-					return wireValue(entry, `param ${entry.name}[${index}]`, element)
+				values: arrayValue(`param ${entry.name}`, value, function wireElement(context, element) {
+					return wireValue(entry, context, element)
 				})
 			}
 		}
@@ -71,11 +74,14 @@ function decodeAnswers<Row>(finds: readonly FindColumn[], rows: readonly (readon
 				throw new SdkInvariantError({ message: `query answer cell ${ordinal} (${column.name}) is absent` })
 			}
 			if (column.slot !== undefined) {
-				decoded[column.name] = decodeCell(`query answer column ${column.name}`, column.slot.field, cell)
+				setOwnField(decoded, column.name, decodeCell(`query answer column ${column.name}`, column.slot.field, cell))
 				return
 			}
-			decoded[column.name] =
+			setOwnField(
+				decoded,
+				column.name,
 				column.closed === undefined ? cell : handleOf(`query answer column ${column.name}`, column.closed, cell)
+			)
 		})
 		Object.freeze(decoded)
 		if (!isAnswerRow<Row>(finds, decoded)) {

package/src/query/scope.ts

@@ -1,5 +1,5 @@
 import type { AnyClosed } from "#closed.ts"
-import { sealedFieldsOf } from "#closed.ts"
+import { memberDescriptor, sealedFieldsOf } from "#closed.ts"
 import { AuthoringError, SdkInvariantError } from "#errors.ts"
 import type { AnyField, Infer, SignatureOf } from "#fields.ts"
 import { rosterOf, signaturesAgree } from "#fields.ts"
@@ -7,7 +7,8 @@ import type { Same, SameLen } from "#judgment.ts"
 import type { ClassLookup, ClassRecordOf, SchemaClasses } from "#law.ts"
 import type { QueryParam } from "#native.ts"
 import type { FindColumn } from "#query/atom.ts"
-import type { AnyRelation, RelationFields } from "#relation.ts"
+import type { AnyRelation } from "#relation.ts"
+import type { FieldsOf } from "#selection.ts"
 
 const term: unique symbol = Symbol("bumbledb.query.term")
 
@@ -15,11 +16,7 @@ const inferred: unique symbol = Symbol("bumbledb.query.inferred")
 
 type MatchOwner = AnyRelation | AnyClosed
 
-type MatchFields<R extends MatchOwner> = R extends AnyClosed
-	? { readonly id: R["id"] } & R["columns"]
-	: R extends AnyRelation
-		? RelationFields<R>
-		: never
+type MatchFields<R extends MatchOwner> = FieldsOf<R>
 
 interface Var<F extends AnyField, RN extends string, K extends string> {
 	readonly [term]: "var"
@@ -125,9 +122,23 @@ function isImportedSource(value: unknown): value is ImportedSource {
 
 type RowOfImport<Q> = InferredOf<Q> extends { readonly row: infer R } ? R : never
 
+type HeadOfImport<Q> = InferredOf<Q> extends { readonly head: infer H } ? H : never
+
+/** Named imported slot so downstream declarations need not spell its private marker. */
+interface ImportedFieldVar<S extends ClassedField, K extends string> extends Var<S["field"], string, K> {
+	readonly [inferred]?: { readonly slot: S }
+}
+
+// Retain the same descriptor and carrier class as the runtime import facade.
+// A host bigint alone cannot distinguish i64 from u64 or a closed identifier.
+type ImportedVar<Q, K extends string> =
+	HeadOfImport<Q> extends Readonly<Record<K, infer S extends ClassedField>>
+		? ImportedFieldVar<S, K>
+		: Var<AnyField, string, K>
+
 type ImportVars<Q> = [RowOfImport<Q>] extends [never]
 	? Readonly<Record<string, Var<AnyField, string, string>>>
-	: { readonly [K in keyof RowOfImport<Q> & string]: Var<AnyField, string, K> }
+	: { readonly [K in keyof RowOfImport<Q> & string]: ImportedVar<Q, K> }
 
 interface ImportFacade {
 	/** The pseudo-owner every import var carries (structurally an owner). */
@@ -157,7 +168,7 @@ function importFacadeOf(source: ImportedSource): ImportFacade {
 	importOrdinal += 1
 	const name = importLabels.get(source) ?? `\u0000import:${importOrdinal}`
 	const columns = new Map<string, FindColumn>()
-	const fields: Array<{ readonly name: string; readonly field: AnyField }> = []
+	const fields: Array<readonly [string, AnyField]> = []
 	for (const column of source.data.finds) {
 		if (column.slot === undefined) {
 			throw new AuthoringError({
@@ -165,18 +176,13 @@ function importFacadeOf(source: ImportedSource): ImportFacade {
 			})
 		}
 		columns.set(column.name, column)
-		fields.push(Object.freeze({ name: column.name, field: column.slot.field }))
+		fields.push([column.name, column.slot.field])
 	}
-	const data = Object.freeze({ name, fields: Object.freeze(fields) })
 	const owner = Object.freeze({
+		kind: "relation" as const,
 		name,
-		data,
-		where(): never {
-			throw new AuthoringError({
-				message: `imported query ${name}: an imported relation expression takes no selection — filter through where() in the consuming rule`
-			})
-		}
-	}) as unknown as MatchOwner & { readonly name: string }
+		fields: Object.freeze(Object.fromEntries(fields))
+	})
 	const facade: ImportFacade = Object.freeze({ owner, source, columns })
 	facadeBySource.set(source, facade)
 	facadeByOwner.set(owner, facade)
@@ -210,7 +216,7 @@ function v(owner: MatchOwner | ImportedSource): Readonly<Record<string, AnyVar>>
 		}
 		return Object.freeze(record)
 	}
-	const member = owner as MatchOwner
+	const member = memberDescriptor(owner as MatchOwner)
 	const record: Record<string, AnyVar> = {}
 	for (const declared of sealedFieldsOf(member)) {
 		const variable: AnyVar = Object.freeze({
@@ -249,10 +255,11 @@ type MintClassOf<Classes extends SchemaClasses, V> =
 		? ClassLookup<ClassRecordOf<Classes, RN>, K>
 		: never
 
-type MintSlotOf<Classes extends SchemaClasses, V extends AnyVar> = {
-	readonly field: V["field"]
-	readonly class: MintClassOf<Classes, V>
-}
+type MintSlotOf<Classes extends SchemaClasses, V extends AnyVar> = [InferredOf<V>] extends [never]
+	? { readonly field: V["field"]; readonly class: MintClassOf<Classes, V> }
+	: InferredOf<V> extends { readonly slot: infer S extends ClassedField }
+		? S
+		: { readonly field: V["field"]; readonly class: MintClassOf<Classes, V> }
 
 type ParamsRecord = Readonly<Record<string, unknown>>
 
@@ -265,15 +272,8 @@ type UnionToIntersection<U> = (U extends unknown ? (member: U) => void : never)
 type ShapeOf<U> = [U] extends [never] ? Record<never, never> : Flatten<UnionToIntersection<U>>
 
 /**
- * A slot's identity for the positive-join judgment: the field's structural
- * signature ({@link SignatureOf} — the ONE interpreter, shared with the
- * face pairing wall) plus the slot's law class.
- */
-type SlotSignature<S extends ClassedField> = readonly [SignatureOf<S["field"]>, S["class"]]
-
-/**
- * A widened slot — a variable minted from an imported query template (its
- * facade columns carry `AnyField`) or fully generic code — cannot be judged
+ * A widened slot — an explicitly erased query template or fully generic
+ * code with no retained descriptor — cannot be judged
  * at the type tier. The degradation law applies: best effort degrades to
  * SILENT, never to a wrong refusal; the runtime join judgment (real
  * descriptors off the imported head's slots) stays authoritative.
@@ -281,7 +281,15 @@ type SlotSignature<S extends ClassedField> = readonly [SignatureOf<S["field"]>,
 type WidenedSlot<S extends ClassedField> = [AnyField] extends [S["field"]] ? true : false
 
 type JoinOk<A extends ClassedField, B extends ClassedField> =
-	WidenedSlot<A> extends true ? true : WidenedSlot<B> extends true ? true : Same<SlotSignature<A>, SlotSignature<B>>
+	WidenedSlot<A> extends true
+		? true
+		: WidenedSlot<B> extends true
+			? true
+			: Same<SignatureOf<A["field"]>, SignatureOf<B["field"]>> extends true
+				? string extends A["class"] | B["class"]
+					? true
+					: Same<A["class"], B["class"]>
+				: false
 
 type U64Wire<F extends AnyField> = F extends { readonly kind: "u64" }
 	? F extends { readonly closed: unknown }
@@ -398,6 +406,7 @@ export type {
 	ClassedField,
 	ExactVars,
 	Flatten,
+	ImportedFieldVar,
 	ImportedSource,
 	ImportVars,
 	InferredOf,