@nmnmcc/ability 1.0.1 → 2.0.1

package/dist/Condition.js

@@ -1,15 +1,15 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { anyDomain, domainOf, hasNoValue, hasValue, isPlainField } from "./Resource.js";
-import * as Arr from "effect/Array";
+import { And, Compare, Exists, In, Not, Or, Predicate, Under, always as always$1, isNode, literal, never as never$1, principalRef, toNode } from "./internal/nodes.js";
+import { evaluate as evaluate$1, evaluateSync as evaluateSync$1, fields as fields$1, partial as partial$1, provide, simplify as simplify$1 } from "./internal/algebra.js";
+import { catalogOf } from "./internal/catalog.js";
+import { decode, toJson } from "./internal/json.js";
+import { kindsIn, satisfiable as satisfiable$1 } from "./internal/search.js";
 import * as Effect from "effect/Effect";
-import * as MutableHashMap from "effect/MutableHashMap";
-import * as Option from "effect/Option";
+import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
-import * as Data from "effect/Data";
+import * as Arr from "effect/Array";
 import { dual } from "effect/Function";
-import * as HashMap from "effect/HashMap";
-import * as HashSet from "effect/HashSet";
-import { hasProperty, isObject } from "effect/Predicate";
+import { hasProperty } from "effect/Predicate";
 import * as SchemaIssue from "effect/SchemaIssue";
 import * as SchemaTransformation from "effect/SchemaTransformation";
 // src/Condition.ts
@@ -46,8 +46,6 @@ var Condition_exports = /* @__PURE__ */ __exportAll({
 	evaluateSync: () => evaluateSync,
 	fields: () => fields,
 	fold: () => fold,
-	hasPredicate: () => hasPredicate,
-	isAst: () => isAst,
 	never: () => never,
 	not: () => not,
 	or: () => or,
@@ -56,29 +54,18 @@ var Condition_exports = /* @__PURE__ */ __exportAll({
 	provideContext: () => provideContext,
 	satisfiable: () => satisfiable,
 	schema: () => schema,
-	simplifier: () => simplifier,
-	simplify: () => simplify,
-	toJsonValue: () => toJsonValue
+	simplify: () => simplify
 });
-const nodes = Data.taggedEnum();
-const operands = Data.taggedEnum();
-const literal = (value) => operands.Literal({ value });
 const isOperand = (u) => hasProperty(u, "_tag") && (u._tag === "Literal" || u._tag === "Principal");
 const toOperand = (value) => isOperand(value) ? value : literal(value);
-const compare = (op) => (field, value) => nodes.Compare({
+const compare = (op) => (field, value) => new Compare({
 	op,
 	field,
 	value: toOperand(value)
 });
-const andOf = (conditions) => nodes.And({ conditions: Arr.copy(conditions) });
-const orOf = (conditions) => nodes.Or({ conditions: Arr.copy(conditions) });
-const makeAnd = (...conditions) => andOf(conditions);
-const makeOr = (...conditions) => orOf(conditions);
-const makeNot = (condition) => nodes.Not({ condition });
-const makePredicate = (name, run) => nodes.Predicate({
-	name,
-	run
-});
+const andOf = (conditions) => new And(conditions);
+const orOf = (conditions) => new Or(conditions);
+const makeNot = (condition) => new Not(condition);
 const sharedBuilder = {
 	eq: compare("eq"),
 	ne: compare("ne"),
@@ -86,20 +73,23 @@ const sharedBuilder = {
 	lte: compare("lte"),
 	gt: compare("gt"),
 	gte: compare("gte"),
-	in: (field, values) => nodes.In({
+	in: (field, values) => new In({
 		field,
-		values: values.map(toOperand)
+		values: Arr.map(Array.from(values), toOperand)
 	}),
-	exists: (field) => nodes.Exists({ field }),
-	under: (...prefix) => nodes.Under({ prefix: prefix.map(toOperand) }),
-	principal: (path) => operands.Principal({ path }),
-	and: makeAnd,
-	or: makeOr,
+	exists: (field) => new Exists({ field }),
+	under: (...prefix) => new Under({ prefix: Arr.map(prefix, toOperand) }),
+	principal: (path) => principalRef(path),
+	and: (...conditions) => andOf(conditions),
+	or: (...conditions) => orOf(conditions),
 	not: makeNot,
-	predicate: (name, test) => makePredicate(name, (value, principal) => Effect.suspend(() => {
-		const result = test(value, principal);
-		return Effect.isEffect(result) ? result : Effect.succeed(result);
-	}))
+	predicate: (name, test) => new Predicate({
+		name,
+		run: (value, principal) => Effect.suspend(() => {
+			const result = test(value, principal);
+			return Effect.isEffect(result) ? result : Effect.succeed(result);
+		})
+	})
 };
 /**
 * Makes a builder. Rules give you a builder with the right types, so you do not
@@ -117,7 +107,7 @@ const builder = () => sharedBuilder;
 * @category constructors
 * @since 0.3.0
 */
-const always = nodes.True();
+const always = always$1;
 /**
 * Always false.
 *
@@ -125,7 +115,7 @@ const always = nodes.True();
 * @category constructors
 * @since 0.3.0
 */
-const never = nodes.False();
+const never = never$1;
 /**
 * True when all the conditions are true. With no conditions, it is true.
 *
@@ -133,7 +123,7 @@ const never = nodes.False();
 * @category combinators
 * @since 0.3.0
 */
-const and = makeAnd;
+const and = ((...conditions) => andOf(conditions));
 /**
 * The same as {@link and}, for a list of conditions of one type. Use it for a
 * long list: a function call may take only so many arguments.
@@ -159,118 +149,15 @@ const orAll = orOf;
 * @category combinators
 * @since 0.3.0
 */
-const or = makeOr;
+const or = ((...conditions) => orOf(conditions));
 /**
 * @stability stable
 * @category combinators
 * @since 0.3.0
 */
 const not = makeNot;
-/**
-* Gets a field of an object by a path with dots. A missing field, or a field
-* under a value that is not an object, gives `null`.
-*/
-/**
-* Tests if an object has a field. A field may be the object's own, or come
-* from its class, as a getter does: `Schema.is` reads such a field too. A
-* name that every object has from `Object.prototype`, such as `constructor`
-* or `toString`, is a field only when the object gives it another value, as
-* its own or from its class.
-*/
-const hasField = (value, key) => {
-	if (Object.hasOwn(value, key)) return true;
-	if (key === "__proto__" || !(key in value)) return false;
-	return !(key in Object.prototype) || value[key] !== Object.prototype[key];
-};
-const getField = (value, path) => Option.match(Arr.reduce(path.split("."), Option.some(value), (cursor, key) => Option.flatMap(cursor, (current) => isObject(current) && hasField(current, key) ? Option.some(current[key]) : Option.none())), {
-	onNone: () => null,
-	onSome: (field) => field === void 0 ? null : field
-});
-const isScalar = (value) => typeof value === "string" || typeof value === "boolean" || typeof value === "number";
-/**
-* Gives the value of an operand. A principal field that is `null`, missing, or
-* not a {@link Scalar} gives `undefined`. No field of a resource is
-* `undefined`, so a test with it is never true. This keeps the check closed: a
-* principal with no id never matches a resource with no owner. It also keeps
-* other values, such as a `bigint`, out of the residual condition.
-*/
-const resolve = (operand, principal) => {
-	if (operand._tag === "Literal") return operand.value;
-	const value = getField(principal, operand.path);
-	return isScalar(value) ? value : void 0;
-};
-const testCompare = (op, left, right) => {
-	if (right === void 0) return false;
-	switch (op) {
-		case "eq": return left === right;
-		case "ne": return left !== right;
-		default: {
-			if (!(typeof left === "number" && typeof right === "number" || typeof left === "string" && typeof right === "string")) return false;
-			const a = left;
-			const b = right;
-			switch (op) {
-				case "lt": return a < b;
-				case "lte": return a <= b;
-				case "gt": return a > b;
-				case "gte": return a >= b;
-			}
-		}
-	}
-};
-/**
-* Gives the values of a resource path. It gives `undefined` when the resource
-* has no path.
-*/
-const pathValues = (value, path) => path?.map((segment) => typeof segment === "string" ? segment : getField(value, segment.field));
-const testUnder = (prefix, input) => {
-	const values = pathValues(input.value, input.path);
-	if (values === void 0 || prefix.length > values.length) return false;
-	return prefix.every((operand, index) => {
-		const value = resolve(operand, input.principal);
-		return value !== void 0 && value === values[index];
-	});
-};
-/**
-* True when a condition has a {@link Predicate}.
-*
-* @stability stable
-* @category predicates
-* @since 1.0.0
-*/
-const hasPredicate = (condition) => hasPredicateIn(condition, /* @__PURE__ */ new Map());
-/**
-* Gives the answer for a key from the memo, or works it out and keeps it.
-*
-* A memo keyed by a node is a native `Map`, because it must find a node by
-* the node itself. An Effect `HashMap` finds a key by `Equal`, and the nodes
-* are Effect data, so it would hash the whole structure of a node, and a
-* shared child again for each path to it.
-*/
-const remember = (memo, key, work) => {
-	if (memo.has(key)) return memo.get(key);
-	const result = work();
-	memo.set(key, result);
-	return result;
-};
-const hasPredicateIn = (ast, memo) => remember(memo, ast, () => {
-	switch (ast._tag) {
-		case "Predicate": return true;
-		case "And":
-		case "Or": return Arr.some(ast.conditions, (child) => hasPredicateIn(child, memo));
-		case "Not": return hasPredicateIn(ast.condition, memo);
-		default: return false;
-	}
-});
-const provideAst = (ast, context, done = /* @__PURE__ */ new Map(), predicates = /* @__PURE__ */ new Map()) => !hasPredicateIn(ast, predicates) ? ast : remember(done, ast, () => {
-	const provide = (child) => provideAst(child, context, done, predicates);
-	switch (ast._tag) {
-		case "Predicate": return makePredicate(ast.name, (value, principal) => Effect.provideContext(ast.run(value, principal), context));
-		case "And": return andOf(Arr.map(ast.conditions, provide));
-		case "Or": return orOf(Arr.map(ast.conditions, provide));
-		case "Not": return makeNot(provide(ast.condition));
-		default: return ast;
-	}
-});
+/** Gives a condition as a node. A value that no constructor made is a defect. */
+const nodeOf = (condition) => toNode(condition);
 /**
 * Gives the services in `context` to every predicate of a condition, so the
 * condition needs no services when it runs.
@@ -279,37 +166,7 @@ const provideAst = (ast, context, done = /* @__PURE__ */ new Map(), predicates =
 * @category services
 * @since 1.0.0
 */
-const provideContext = dual(2, provideAst);
-const evaluateSyncAst = (ast, input) => evaluateSyncNode(ast, input, /* @__PURE__ */ new Map());
-const evaluateSyncNode = (ast, input, done) => remember(done, ast, () => evaluateSyncOnce(ast, input, done));
-const evaluateSyncOnce = (ast, input, done) => {
-	switch (ast._tag) {
-		case "True": return true;
-		case "False": return false;
-		case "Compare": return testCompare(ast.op, getField(input.value, ast.field), resolve(ast.value, input.principal));
-		case "In": {
-			const field = getField(input.value, ast.field);
-			return ast.values.some((operand) => resolve(operand, input.principal) === field);
-		}
-		case "Exists": return getField(input.value, ast.field) !== null;
-		case "Under": return testUnder(ast.prefix, input);
-		case "And": return Arr.every(ast.conditions, (child) => evaluateSyncNode(child, input, done));
-		case "Or": return Arr.some(ast.conditions, (child) => evaluateSyncNode(child, input, done));
-		case "Not": return !evaluateSyncNode(ast.condition, input, done);
-		case "Predicate": throw new globalThis.Error(`The predicate "${ast.name}" needs an Effect. Use Condition.evaluate.`);
-	}
-};
-const evaluateAst = (ast, input, predicates = /* @__PURE__ */ new Map()) => {
-	if (!hasPredicateIn(ast, predicates)) return Effect.sync(() => evaluateSyncAst(ast, input));
-	const evaluate = (child) => evaluateAst(child, input, predicates);
-	switch (ast._tag) {
-		case "Predicate": return ast.run(input.value, input.principal);
-		case "Not": return Effect.map(evaluate(ast.condition), (value) => !value);
-		case "And": return Effect.map(Effect.findFirst(ast.conditions, (child) => Effect.map(evaluate(child), (value) => !value)), Option.isNone);
-		case "Or": return Effect.map(Effect.findFirst(ast.conditions, evaluate), Option.isSome);
-		default: return Effect.sync(() => evaluateSyncAst(ast, input));
-	}
-};
+const provideContext = dual(2, (condition, context) => provide(nodeOf(condition), context));
 /**
 * Tests a condition on a value. A predicate may fail with its error. When the
 * condition has a predicate, the input must have the value and the principal
@@ -319,7 +176,7 @@ const evaluateAst = (ast, input, predicates = /* @__PURE__ */ new Map()) => {
 * @category evaluation
 * @since 0.3.0
 */
-const evaluate = dual(2, evaluateAst);
+const evaluate = ((condition, input) => Effect.suspend(() => evaluate$1(nodeOf(condition), input)));
 /**
 * Tests a condition with no predicate on a value, at once.
 *
@@ -327,203 +184,17 @@ const evaluate = dual(2, evaluateAst);
 * @category evaluation
 * @since 0.3.0
 */
-const evaluateSync = dual(2, evaluateSyncAst);
-const makeMemo = () => ({
-	simple: /* @__PURE__ */ new Map(),
-	predicates: /* @__PURE__ */ new Map(),
-	ids: /* @__PURE__ */ new Map(),
-	structures: MutableHashMap.empty()
-});
-const literalText = (value) => typeof value === "number" ? `n${Object.is(value, -0) ? "-0" : String(value)}` : `${typeof value}:${JSON.stringify(value)}`;
-const operandText = (operand) => operand._tag === "Literal" ? `L${literalText(operand.value)}` : `R${JSON.stringify(operand.path)}`;
-const structureText = (ast, memo) => {
-	const id = (child) => structureId(child, memo);
-	switch (ast._tag) {
-		case "True":
-		case "False": return ast._tag;
-		case "Compare": return `C${ast.op}:${JSON.stringify(ast.field)}:${operandText(ast.value)}`;
-		case "In": return `I${JSON.stringify(ast.field)}:${Arr.map(ast.values, operandText).join(",")}`;
-		case "Exists": return `E${JSON.stringify(ast.field)}`;
-		case "Under": return `U${Arr.map(ast.prefix, operandText).join(",")}`;
-		case "And":
-		case "Or": return `${ast._tag}:${Arr.map(ast.conditions, id).join(",")}`;
-		case "Not": return `N${String(id(ast.condition))}`;
-		case "Predicate": return;
-	}
-};
-/**
-* Gives the number of the structure of a node. Two nodes with the same
-* structure get the same number, so a set of numbers finds an equal node at
-* once. The hash of Effect data would walk a shared child again for each path
-* to it. A new number is the count of the numbered nodes, so it is new.
-*/
-const structureId = (ast, memo) => remember(memo.ids, ast, () => {
-	const text = structureText(ast, memo);
-	const fresh = memo.ids.size;
-	if (text === void 0) return fresh;
-	return Option.getOrElse(MutableHashMap.get(memo.structures, text), () => {
-		MutableHashMap.set(memo.structures, text, fresh);
-		return fresh;
-	});
-});
-const dedupe = (conditions, memo) => {
-	const ids = Arr.map(conditions, (condition) => structureId(condition, memo));
-	const first = HashMap.fromIterable(Arr.reverse(Arr.map(ids, (id, index) => [id, index])));
-	return Arr.filter(conditions, (_, index) => Option.contains(HashMap.get(first, ids[index]), index));
-};
-/**
-* Removes the children that the other children make useless. In an `Or`,
-* `a OR (a AND b)` is `a`. In an `And`, `a AND (a OR b)` is `a`. The
-* children are already without copies.
-*/
-const absorb = (inner, conditions, memo) => {
-	const all = HashSet.fromIterable(Arr.map(conditions, (condition) => structureId(condition, memo)));
-	return Arr.filter(conditions, (condition) => condition._tag !== inner || !Arr.some(condition.conditions, (part) => HashSet.has(all, structureId(part, memo))));
-};
-/**
-* Removes children that do not change the result. A predicate may fail, and it
-* may give another answer when it runs again. So when a child has a predicate,
-* every child stays, and each one runs in its place.
-*/
-const reduce = (inner, conditions, memo) => Arr.some(conditions, (condition) => hasPredicateIn(condition, memo.predicates)) ? conditions : absorb(inner, dedupe(conditions, memo), memo);
-/**
-* Puts the children of a child of the same kind into the node. A child with a
-* predicate stays one child: its children all stay anyway, and one shared
-* child would come again for each path to it, so the node could grow without
-* end.
-*/
-const flatten = (tag, conditions, memo) => Arr.flatMap(conditions, (child) => {
-	const simple = simplifyIn(child, memo);
-	return simple._tag === tag && !hasPredicateIn(simple, memo.predicates) ? simple.conditions : [simple];
-});
-/**
-* Gives the result of an `And` with a `False` child, or of an `Or` with a
-* `True` child. The children are tested in order, so a predicate before the
-* constant still runs, and it may fail. When there is such a predicate, the
-* children before the constant stay, so the failure is not lost. The other
-* children stay too, because they decide if the predicate runs.
-*/
-const shortCircuit = (tag, children, index, memo) => {
-	const constant = tag === "And" ? never : always;
-	const neutral = tag === "And" ? "True" : "False";
-	const before = Arr.filter(Arr.take(children, index), (child) => child._tag !== neutral);
-	if (!Arr.some(before, (child) => hasPredicateIn(child, memo.predicates))) return constant;
-	return tag === "And" ? andOf([...before, constant]) : orOf([...before, constant]);
-};
-const simplifyIn = (ast, memo) => remember(memo.simple, ast, () => {
-	const result = simplifyNode(ast, memo);
-	memo.simple.set(result, result);
-	return result;
-});
-const simplifyJunction = (tag, conditions, memo) => {
-	const constant = tag === "And" ? "False" : "True";
-	const neutral = tag === "And" ? "True" : "False";
-	const flat = flatten(tag, conditions, memo);
-	return Option.match(Arr.findFirstIndex(flat, (child) => child._tag === constant), {
-		onSome: (stop) => shortCircuit(tag, flat, stop, memo),
-		onNone: () => {
-			const unique = reduce(tag === "And" ? "Or" : "And", Arr.filter(flat, (child) => child._tag !== neutral), memo);
-			return unique.length === 0 ? tag === "And" ? always : never : unique.length === 1 ? unique[0] : tag === "And" ? andOf(unique) : orOf(unique);
-		}
-	});
-};
-const simplifyNode = (ast, memo) => {
-	switch (ast._tag) {
-		case "And":
-		case "Or": return simplifyJunction(ast._tag, ast.conditions, memo);
-		case "Not": {
-			const child = simplifyIn(ast.condition, memo);
-			switch (child._tag) {
-				case "True": return never;
-				case "False": return always;
-				case "Not": return child.condition;
-				case "Compare":
-					if (child.value._tag === "Literal" && (child.op === "eq" || child.op === "ne")) return nodes.Compare({
-						op: child.op === "eq" ? "ne" : "eq",
-						field: child.field,
-						value: child.value
-					});
-					return makeNot(child);
-				default: return makeNot(child);
-			}
-		}
-		case "In": return ast.values.length === 0 ? never : ast;
-		default: return ast;
-	}
-};
-const simplifyAst = (ast) => simplifyIn(ast, makeMemo());
+const evaluateSync = (condition, input) => evaluateSync$1(nodeOf(condition), input);
 /**
 * Makes a condition smaller without a change to its meaning. It removes `True`
 * and `False` from `And` and `Or`, joins nested `And` and `Or` nodes, and
-* removes double `Not` nodes.
+* removes double `Not` nodes and copies of a child.
 *
 * @stability stable
 * @category evaluation
 * @since 0.3.0
 */
-const simplify = simplifyAst;
-/**
-* Makes a {@link simplify} function that keeps its work for the parts it has
-* seen. Use one for many calls on conditions that share parts, such as the
-* steps of one residual condition. Do not keep it for long: it keeps every
-* part that it has seen.
-*
-* @stability stable
-* @category evaluation
-* @since 1.0.0
-*/
-const simplifier = () => {
-	const memo = makeMemo();
-	return ((ast) => simplifyIn(ast, memo));
-};
-/**
-* Puts the value of the principal into an operand. It gives `undefined` for a
-* principal field with no value. See {@link resolve}.
-*/
-const bindOperand = (operand, principal) => {
-	if (operand._tag === "Literal") return operand;
-	const value = resolve(operand, principal);
-	return value === void 0 ? void 0 : literal(value);
-};
-const expandUnder = (prefix, principal, path) => {
-	if (path === void 0 || prefix.length > path.length) return never;
-	const parts = Arr.map(prefix, (operand, index) => {
-		const value = resolve(operand, principal);
-		const segment = path[index];
-		return value === void 0 ? never : typeof segment === "string" ? segment === value ? always : never : nodes.Compare({
-			op: "eq",
-			field: segment.field,
-			value: literal(value)
-		});
-	});
-	return andOf(parts);
-};
-const bind = (ast, principal, path, done = /* @__PURE__ */ new Map()) => remember(done, ast, () => bindOnce(ast, principal, path, done));
-const bindOnce = (ast, principal, path, done) => {
-	switch (ast._tag) {
-		case "Compare": {
-			const value = bindOperand(ast.value, principal);
-			return value === void 0 ? never : nodes.Compare({
-				op: ast.op,
-				field: ast.field,
-				value
-			});
-		}
-		case "In": return nodes.In({
-			field: ast.field,
-			values: ast.values.flatMap((operand) => {
-				const value = bindOperand(operand, principal);
-				return value === void 0 ? [] : [value];
-			})
-		});
-		case "Under": return expandUnder(ast.prefix, principal, path);
-		case "And": return andOf(ast.conditions.map((child) => bind(child, principal, path, done)));
-		case "Or": return orOf(ast.conditions.map((child) => bind(child, principal, path, done)));
-		case "Not": return makeNot(bind(ast.condition, principal, path, done));
-		case "Predicate": return makePredicate(ast.name, (value) => ast.run(value, principal));
-		default: return ast;
-	}
-};
+const simplify = ((condition) => condition.pipe(nodeOf, simplify$1));
 /**
 * Puts the principal into a condition and expands `Under` with the path of the
 * resource. The result is simplified. It has no principal fields and no
@@ -534,7 +205,7 @@ const bindOnce = (ast, principal, path, done) => {
 * @category evaluation
 * @since 0.3.0
 */
-const partial = dual(2, (ast, input) => simplifyAst(bind(ast, input.principal, input.path)));
+const partial = ((condition, input) => partial$1(nodeOf(condition), input));
 /**
 * The error when `fold` can not change a node.
 *
@@ -547,25 +218,21 @@ const literalValue = (operand, field) => {
 	if (operand._tag !== "Literal") throw Untranslatable.make({ reason: `The field "${field}" uses a principal field. Call Condition.partial first.` });
 	return operand.value;
 };
-/**
-* Folds one node. The memo keeps the result of each node, so a node that is a
-* child of many nodes is folded one time.
-*/
-const foldAst = (ast, interpreter, done = /* @__PURE__ */ new Map()) => remember(done, ast, () => foldOnce(ast, interpreter, done));
-const foldOnce = (ast, interpreter, done) => {
-	switch (ast._tag) {
+/** Folds a condition. A shared child is folded again for each place. */
+const foldNode = (node, interpreter) => {
+	switch (node._tag) {
 		case "True": return interpreter.true();
 		case "False": return interpreter.false();
-		case "Compare": return interpreter.compare(ast.op, ast.field, literalValue(ast.value, ast.field));
-		case "In": return interpreter.in(ast.field, ast.values.map((operand) => literalValue(operand, ast.field)));
-		case "Exists": return interpreter.exists(ast.field);
+		case "Compare": return interpreter.compare(node.op, node.field, literalValue(node.value, node.field));
+		case "In": return interpreter.in(node.field, Arr.map(node.values, (operand) => literalValue(operand, node.field)));
+		case "Exists": return interpreter.exists(node.field);
 		case "Under": throw Untranslatable.make({ reason: "An Under node needs the resource path. Call Condition.partial first." });
-		case "And": return interpreter.and(Arr.map(ast.conditions, (child) => foldAst(child, interpreter, done)));
-		case "Or": return interpreter.or(Arr.map(ast.conditions, (child) => foldAst(child, interpreter, done)));
-		case "Not": return interpreter.not(foldAst(ast.condition, interpreter, done));
+		case "And": return interpreter.and(Arr.map(node.conditions, (child) => foldNode(child, interpreter)));
+		case "Or": return interpreter.or(Arr.map(node.conditions, (child) => foldNode(child, interpreter)));
+		case "Not": return interpreter.not(foldNode(node.condition, interpreter));
 		case "Predicate":
-			if (interpreter.predicate === void 0) throw Untranslatable.make({ reason: `The predicate "${ast.name}" can not become a query` });
-			return interpreter.predicate(ast.name);
+			if (interpreter.predicate === void 0) throw Untranslatable.make({ reason: `The predicate "${node.name}" can not become a query` });
+			return interpreter.predicate(node.name);
 	}
 };
 /**
@@ -577,547 +244,65 @@ const foldOnce = (ast, interpreter, done) => {
 * @category converting
 * @since 0.3.0
 */
-const fold = dual(2, (ast, interpreter) => Effect.try({
-	try: () => foldAst(ast, interpreter),
+const fold = dual(2, (condition, interpreter) => Effect.try({
+	try: () => foldNode(nodeOf(condition), interpreter),
 	catch: (cause) => {
 		if (cause instanceof Untranslatable) return cause;
 		throw cause;
 	}
 }));
 /**
-* The fields that a condition uses.
+* The fields that a condition uses, in the order that they first come.
 *
 * @stability stable
 * @category getters
 * @since 0.3.0
 */
-const fields = (condition) => fieldsIn(condition, /* @__PURE__ */ new Map());
-/**
-* The fields of a node, in the order that they first come. A `HashSet` would
-* not keep that order, so it only says which fields came before.
-*/
-/** Leaves out each string that came before, in linear time. */
-const dedupeStrings = (values) => Arr.flatten(Arr.mapAccum(values, HashSet.empty(), (seen, value) => [HashSet.add(seen, value), HashSet.has(seen, value) ? [] : [value]])[1]);
-const fieldsIn = (ast, memo) => remember(memo, ast, () => {
-	switch (ast._tag) {
-		case "Compare":
-		case "In":
-		case "Exists": return [ast.field];
-		case "And":
-		case "Or": return dedupeStrings(Arr.flatMap(ast.conditions, (child) => fieldsIn(child, memo)));
-		case "Not": return fieldsIn(ast.condition, memo);
-		default: return [];
-	}
-});
-const satisfiability = Data.taggedEnum();
-/** Stands for a value with parts, such as a struct or a date. */
-const opaque = Object.freeze({});
-/** Marks a field that a step of the search did not fix. */
-const free = Symbol("free");
-/** The least number that is greater than `value`. */
-const nextUp = (value) => {
-	if (Number.isNaN(value) || value === Infinity) return value;
-	if (value === 0) return Number.MIN_VALUE;
-	const view = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
-	view.setFloat64(0, value);
-	const bits = view.getBigUint64(0);
-	view.setBigUint64(0, value > 0 ? bits + 1n : bits - 1n);
-	return view.getFloat64(0);
-};
-/**
-* Gives one number from each part of the number line that the constants
-* make: each constant, and one number between each two neighbours when there
-* is one. The ends of the domain are in the list too.
-*/
-const numberCells = (kind, constants) => {
-	const integer = kind === "integer";
-	const low = integer ? Number.MIN_SAFE_INTEGER : kind === "finite" ? -Number.MAX_VALUE : -Infinity;
-	const high = integer ? Number.MAX_SAFE_INTEGER : kind === "finite" ? Number.MAX_VALUE : Infinity;
-	const known = Arr.filter(constants, (value) => !Number.isNaN(value));
-	const ordered = [
-		low,
-		high,
-		...Arr.filter(Arr.flatMap(known, (value) => integer && Number.isFinite(value) ? [Math.floor(value), Math.ceil(value)] : [value]), (value) => value >= low && value <= high)
-	].sort((a, b) => a - b);
-	const sorted = Arr.dedupeAdjacentWith(ordered, (a, b) => a === b);
-	const cells = Arr.flatMap(sorted, (value, index) => {
-		const after = sorted[index + 1];
-		const between = integer ? value + 1 : nextUp(value);
-		return after !== void 0 && between < after ? [value, between] : [value];
-	});
-	return kind === "any" ? Arr.append(cells, NaN) : cells;
-};
-/**
-* Gives one string from each part that the constants make. Strings are in the
-* order of their UTF-16 code units, as `<` sees them. The least string after
-* `a` is `a + "\0"`, so there is a string between `a` and `b` exactly when
-* `b` is not `a + "\0"`.
-*/
-const stringCells = (constants) => {
-	const ordered = [...constants].sort();
-	const sorted = Arr.dedupeAdjacentWith(ordered, (a, b) => a === b);
-	if (sorted.length === 0) return [""];
-	return [...sorted[0] === "" ? [] : [""], ...Arr.flatMap(sorted, (value, index) => {
-		const next = `${value}\0`;
-		return next === sorted[index + 1] ? [value] : [value, next];
-	})];
-};
-/**
-* Gives one value from each cell of a field. Each test of a field compares it
-* with constants, so the constants cut the domain into a few cells, and every
-* test gives the same answer for all the values of one cell.
-*/
-const cellsOf = (domain, constants) => dedupeCells([
-	...domain.null ? [null] : [],
-	...domain.object ? [opaque] : [],
-	...domain.boolean ? [true, false] : [],
-	...domain.string ? stringCells(Arr.filter(constants, (value) => typeof value === "string")) : [],
-	...domain.number === "none" ? [] : numberCells(domain.number, Arr.filter(constants, (value) => typeof value === "number")),
-	...domain.literals
-]);
-/**
-* A text for a cell. Two cells get one text when every test gives the same
-* answer for them: `0` and `-0` are one, and `NaN` is one.
-*/
-const cellText = (cell) => cell === opaque ? "opaque" : typeof cell === "number" ? `number:${Object.is(cell, -0) ? "0" : String(cell)}` : `${typeof cell}:${String(cell)}`;
-/**
-* Keeps the first cell of each text, in order. A map from each text to its
-* first place does it in one pass. A test of each pair would take a very long
-* time for many constants.
-*/
-const dedupeCells = (cells) => {
-	const texts = Arr.map(cells, cellText);
-	const first = HashMap.fromIterable(Arr.reverse(Arr.map(texts, (text, index) => [text, index])));
-	return Arr.filter(cells, (_, index) => Option.contains(HashMap.get(first, texts[index]), index));
-};
-var OutOfBudget = class {};
-const literalOf = (operand) => {
-	if (operand._tag !== "Literal") throw new Error("Condition.satisfiable needs a condition with no principal fields. Call Condition.partial first.");
-	return operand.value;
-};
-/**
-* The value of the field `name` after `field` gets `value`. A field below
-* `field` is `null` when `value` is not a value with parts.
-*/
-const fixedValue = (name, field, value) => name === field ? value : name.startsWith(`${field}.`) ? value === opaque ? free : null : free;
-const testFixed = (ast, value, search) => {
-	switch (ast._tag) {
-		case "Compare": return testCompare(ast.op, value, literalOf(ast.value));
-		case "In": return !Number.isNaN(value) && HashSet.has(remember(search.members, ast, () => HashSet.fromIterable(Arr.map(Arr.filter(Arr.map(ast.values, literalOf), (literal) => !Number.isNaN(literal)), cellText))), cellText(value));
-		case "Exists": return value !== null;
-	}
-};
-/**
-* Puts one value into a field, and into the fields below it. The memo has a
-* node for each node that the step visits, so its size is the work of the
-* step.
-*/
-const fix = (ast, field, value, search, done) => remember(done, ast, () => {
-	const fixChild = (child) => fix(child, field, value, search, done);
-	switch (ast._tag) {
-		case "Compare":
-		case "In":
-		case "Exists": {
-			const known = fixedValue(ast.field, field, value);
-			return known === free ? ast : testFixed(ast, known, search) ? always : never;
-		}
-		case "And": return andOf(Arr.map(ast.conditions, fixChild));
-		case "Or": return orOf(Arr.map(ast.conditions, fixChild));
-		case "Not": return makeNot(fixChild(ast.condition));
-		default: return ast;
-	}
-});
-/**
-* Counts the tests of each field. Each node is visited one time, so the work
-* is the number of nodes, and the walk gives that work back for the budget.
-* The counts and the seen nodes are a memo of this walk only.
-*/
-const countFields = (ast) => {
-	const counts = MutableHashMap.empty();
-	const seen = /* @__PURE__ */ new Set();
-	const visit = (node) => {
-		if (seen.has(node)) return;
-		seen.add(node);
-		switch (node._tag) {
-			case "Compare":
-			case "In":
-			case "Exists":
-				MutableHashMap.set(counts, node.field, Option.getOrElse(MutableHashMap.get(counts, node.field), () => 0) + 1);
-				return;
-			case "And":
-			case "Or": return Arr.forEach(node.conditions, visit);
-			case "Not": return visit(node.condition);
-			default: return;
-		}
-	};
-	visit(ast);
-	return {
-		counts,
-		work: seen.size
-	};
-};
-/**
-* Picks the next field to split on. A field comes before the fields below it,
-* so a value of a field can fix them. Then a field in more tests comes first,
-* and then the first name in order, so the choice is the same each time.
-*/
-const nextField = (counts) => {
-	const depth = (field) => field.split(".").length;
-	const [first, ...rest] = Array.from(counts);
-	return Arr.reduce(rest, first, (best, next) => depth(next[0]) < depth(best[0]) || depth(next[0]) === depth(best[0]) && (next[1] > best[1] || next[1] === best[1] && next[0] < best[0]) ? next : best)[0];
-};
-/**
-* Finds values of the fields that make the condition true. It splits on one
-* field at a time, and tries one value from each cell of the field.
-*/
-const searchAst = (ast, search, state, assignment) => {
-	const current = simplifyIn(ast, search.memo);
-	if (current._tag === "True") return {
-		assignment: Option.some(assignment),
-		state
-	};
-	if (current._tag === "False") return {
-		assignment: Option.none(),
-		state
-	};
-	const id = structureId(current, search.memo);
-	if (HashSet.has(state.failed, id)) return {
-		assignment: Option.none(),
-		state
-	};
-	const counted = countFields(current);
-	if (state.steps + counted.work > search.budget) throw new OutOfBudget();
-	const field = nextField(counted.counts);
-	const cells = search.cells(field);
-	const result = Arr.reduce(cells, {
-		assignment: Option.none(),
-		state
-	}, (before, cell) => {
-		if (Option.isSome(before.assignment)) return before;
-		const done = /* @__PURE__ */ new Map();
-		const fixed = fix(current, field, cell, search, done);
-		const steps = before.state.steps + done.size;
-		if (steps > search.budget) throw new OutOfBudget();
-		return searchAst(fixed, search, {
-			...before.state,
-			steps
-		}, [...assignment, [field, cell]]);
-	});
-	return Option.isSome(result.assignment) ? result : {
-		assignment: Option.none(),
-		state: {
-			...result.state,
-			failed: HashSet.add(result.state.failed, id)
-		}
-	};
-};
-/**
-* Puts a value at a path in an object, and gives a new object. A value with
-* parts (`opaque`) becomes an empty object, and it keeps an object that is
-* there.
-*/
-const setPath = (root, names, value) => {
-	const [name, ...rest] = names;
-	if (name === void 0) return root;
-	const inner = Object.hasOwn(root, name) ? root[name] : void 0;
-	if (rest.length === 0) return value === opaque && isObject(inner) ? root : {
-		...root,
-		[name]: value === opaque ? {} : value
-	};
-	const base = isObject(inner) && inner !== opaque ? inner : {};
-	return {
-		...root,
-		[name]: setPath(base, rest, value)
-	};
-};
-const exampleOf = (assignment) => Arr.reduce(assignment, {}, (root, [field, value]) => setPath(root, field.split("."), value));
-const addConstants = (left, right) => HashMap.reduce(right, left, (all, values, field) => HashMap.set(all, field, HashSet.union(Option.getOrElse(HashMap.get(all, field), HashSet.empty), values)));
-const constantsOf = (ast, memo = /* @__PURE__ */ new Map()) => remember(memo, ast, () => {
-	switch (ast._tag) {
-		case "Compare": return HashMap.make([ast.field, HashSet.make(literalOf(ast.value))]);
-		case "In": return HashMap.make([ast.field, HashSet.fromIterable(Arr.map(ast.values, literalOf))]);
-		case "Exists": return HashMap.make([ast.field, HashSet.empty()]);
-		case "Under": throw new Error("Condition.satisfiable needs a condition with no Under nodes. Call Condition.partial first.");
-		case "And":
-		case "Or": return Arr.reduce(ast.conditions, HashMap.empty(), (all, child) => addConstants(all, constantsOf(child, memo)));
-		case "Not": return constantsOf(ast.condition, memo);
-		default: return HashMap.empty();
-	}
-});
-/**
-* The most fields that the search of {@link satisfiable} takes. Past it, the
-* answer is `Unknown` with the reason `"budget"`.
-*/
-const maxSearchFields = 256;
-/**
-* The most parts of a field path that the search of {@link satisfiable}
-* takes. Past it, the answer is `Unknown` with the reason `"budget"`.
-*/
-const maxSearchParts = 256;
-const satisfiableAst = (ast, options = {}) => {
-	if (hasPredicate(ast)) return satisfiability.Unknown({ reason: "predicate" });
-	const schema = options.schema;
-	const tested = fields(ast);
-	if (schema !== void 0 && hasNoValue(schema)) return satisfiability.Unsatisfiable();
-	const complete = schema === void 0 || hasValue(schema);
-	if (schema !== void 0 && !Arr.every(tested, (field) => isPlainField(schema, field))) return satisfiability.Unknown({ reason: "schema" });
-	if (tested.length > maxSearchFields || Arr.some(tested, (field) => field.split(".", 257).length > maxSearchParts)) return satisfiability.Unknown({ reason: "budget" });
-	const constants = constantsOf(ast);
-	const cells = MutableHashMap.empty();
-	const search = {
-		memo: makeMemo(),
-		members: /* @__PURE__ */ new Map(),
-		cells: (field) => Option.getOrElse(MutableHashMap.get(cells, field), () => {
-			const known = HashMap.get(constants, field);
-			if (Option.isSome(known) && HashSet.size(known.value) > (options.budget ?? 1e6)) throw new OutOfBudget();
-			const found = cellsOf(schema === void 0 ? anyDomain : domainOf(schema, field), Array.from(Option.getOrElse(HashMap.get(constants, field), HashSet.empty)));
-			MutableHashMap.set(cells, field, found);
-			return found;
-		}),
-		budget: options.budget ?? 1e6
-	};
-	try {
-		const found = searchAst(ast, search, {
-			steps: 0,
-			failed: HashSet.empty()
-		}, []);
-		return Option.match(found.assignment, {
-			onNone: () => satisfiability.Unsatisfiable(),
-			onSome: (assignment) => complete ? satisfiability.Satisfiable({ example: exampleOf(assignment) }) : satisfiability.Unknown({ reason: "schema" })
-		});
-	} catch (error) {
-		if (error instanceof OutOfBudget) return satisfiability.Unknown({ reason: "budget" });
-		throw error;
-	}
-};
+const fields = (condition) => condition.pipe(nodeOf, fields$1);
 /**
 * Tests if some value makes a condition true, and gives such a value.
 *
 * Call {@link partial} first: the condition must have no principal fields and
 * no `Under` nodes. A condition with a predicate gives `Unknown`.
 *
-* With `options.schema`, each field of the condition must be a plain scalar
-* field of the Schema (see `Resource.isPlainField`). Else the answer is
-* `Unknown` with the reason `"schema"`: for another field, a value may have
-* data that the Schema does not show, so the model of its values is not
-* exact.
+* Each test of a condition compares one field with constants, so the
+* constants cut the values of each field into a few cells. The search tries
+* one value from each cell, one field at a time. The values of a field come
+* from the shape of the Schema in `options.schema`: its literals, `null` for
+* a nullable or optional field, and finite or integer numbers.
 *
-* The answer is exact. Each test of a condition compares one field with
-* constants, so the constants cut the values of each field into a few cells.
-* The search tries one value from each cell, one field at a time. The values
-* of a field come from the Schema in `options.schema`: its literals, `null`
-* for a nullable or optional field, and finite or integer numbers. A field
-* with another Schema check is not a plain field, so the search never tries a
-* value that such a check stops.
+* The search reads the shape of the Schema, not its other checks, such as a
+* minimum length. So `Unsatisfiable` holds for every value of the Schema. A
+* `Satisfiable` example fits the shape, but a check may still stop it.
 *
 * The problem is as hard as boolean satisfiability, so the search has a
 * budget. Past it, the answer is `Unknown`. A condition with more than 256
-* fields, or with a field path of more than 256 parts, gives `Unknown` too.
+* fields gives `Unknown` too.
 *
 * @stability stable
 * @category evaluation
 * @since 1.0.0
 */
-const satisfiable = dual((args) => isObject(args[0]) && hasProperty(args[0], "_tag"), satisfiableAst);
-const operandJson = (operand) => operand._tag === "Literal" && typeof operand.value === "number" && !Number.isFinite(operand.value) ? {
-	...operand,
-	value: { nonFinite: String(operand.value) }
-} : operand;
-const jsonIn = (ast, done) => remember(done, ast, () => {
-	switch (ast._tag) {
-		case "Compare": return {
-			...ast,
-			value: operandJson(ast.value)
-		};
-		case "In": return {
-			...ast,
-			values: Arr.map(ast.values, operandJson)
-		};
-		case "Under": return {
-			...ast,
-			prefix: Arr.map(ast.prefix, operandJson)
-		};
-		case "And":
-		case "Or": return {
-			...ast,
-			conditions: Arr.map(ast.conditions, (child) => jsonIn(child, done))
-		};
-		case "Not": return {
-			...ast,
-			condition: jsonIn(ast.condition, done)
-		};
-		default: return ast;
-	}
-});
-/**
-* Gives a condition as a value that `JSON.stringify` keeps with no loss. JSON
-* has no `Infinity`, `-Infinity` or `NaN`: it writes `null` in their place,
-* and a test with `null` has another meaning. Such a number becomes an object
-* that {@link schema} does not decode, so a policy with it fails to load and
-* never gives a wrong answer.
-*
-* @stability stable
-* @category conversions
-* @since 1.0.0
-*/
-const toJsonValue = (condition) => jsonIn(condition, /* @__PURE__ */ new Map());
-const ScalarSchema = Schema.Union([
-	Schema.String,
-	Schema.Finite,
-	Schema.Boolean,
-	Schema.Null
-]);
-const OperandSchema = Schema.Union([Schema.TaggedStruct("Literal", { value: ScalarSchema }), Schema.TaggedStruct("Principal", { path: Schema.String })]);
-const Recursive = Schema.suspend(() => shape);
-/**
-* The most levels of objects and arrays in the JSON form of a condition. The
-* Schema of a condition calls itself for each level, so a much deeper input
-* could fill the stack before it fails.
-*/
-const maxJsonDepth = 1e3;
-/**
-* The most objects and arrays in the JSON form of an input, with a shared one
-* counted for each place. The decoder writes out a shared one each time, so
-* an input with few objects may give a very large tree.
-*/
-const maxInputNodes = 1e6;
-/**
-* Measures a value, or gives `undefined` when it is higher than `levels`. A
-* shared object is measured one time. The walk stops at that height, so it
-* does not fill the stack itself. The memo is a native `Map`, because it
-* must find an object by the object itself.
-*/
-const measure = (input, levels, memo) => {
-	if (typeof input !== "object" || input === null) return {
-		size: 0,
-		height: 0
-	};
-	const cached = memo.get(input);
-	if (cached !== void 0 && ("failed" in cached ? levels <= cached.failed : true)) return "failed" in cached || cached.height > levels ? void 0 : cached;
-	const result = levels === 0 || !isPlainData(input) ? void 0 : Arr.reduce(Object.values(input), {
-		size: 1,
-		height: 1
-	}, (total, child) => {
-		const measured = total === void 0 ? void 0 : measure(child, levels - 1, memo);
-		return total === void 0 || measured === void 0 ? void 0 : {
-			size: total.size + measured.size,
-			height: Math.max(total.height, 1 + measured.height)
-		};
-	});
-	memo.set(input, result ?? { failed: levels });
-	return result;
-};
-/**
-* Tests if each own key of an object is a plain data key that a loop over the
-* keys sees. The `length` of an array is the one key that is not seen. The
-* decoder reads keys of the prototypes too, so a prototype other than the
-* one of a plain object or an array may have only methods, as the prototype
-* of a class has.
-*/
-const isPlainData = (input) => Arr.every(Reflect.ownKeys(input), (key) => {
-	const property = Object.getOwnPropertyDescriptor(input, key);
-	return property !== void 0 && "value" in property && (property.enumerable === true || Array.isArray(input) && key === "length");
-}) && hasOnlyMethods(Object.getPrototypeOf(input));
-/** Tests if the prototypes from `prototype` up have only methods. */
-const hasOnlyMethods = (prototype) => prototype === null || prototype === Object.prototype || prototype === Array.prototype || typeof prototype === "object" && Arr.every(Reflect.ownKeys(prototype), (key) => {
-	const property = Object.getOwnPropertyDescriptor(prototype, key);
-	return typeof key === "symbol" || key === "constructor" || property !== void 0 && "value" in property && typeof property.value === "function";
-}) && hasOnlyMethods(Object.getPrototypeOf(prototype));
-/** Tests if a value is low and small enough to decode. */
-const fitsLimits = (input) => {
-	const measured = measure(input, maxJsonDepth, /* @__PURE__ */ new Map());
-	return measured === void 0 ? `A condition may have at most ${String(maxJsonDepth)} levels of JSON` : measured.size > maxInputNodes ? `A condition may have at most ${String(maxInputNodes)} objects and arrays in JSON` : true;
-};
-/** The shape of a condition, with no check of its depth. */
-const shape = Schema.Union([
-	Schema.TaggedStruct("True", {}),
-	Schema.TaggedStruct("False", {}),
-	Schema.TaggedStruct("Compare", {
-		op: Schema.Literals([
-			"eq",
-			"ne",
-			"lt",
-			"lte",
-			"gt",
-			"gte"
-		]),
-		field: Schema.String,
-		value: OperandSchema
-	}),
-	Schema.TaggedStruct("In", {
-		field: Schema.String,
-		values: Schema.Array(OperandSchema)
-	}),
-	Schema.TaggedStruct("Exists", { field: Schema.String }),
-	Schema.TaggedStruct("Under", { prefix: Schema.Array(OperandSchema) }),
-	Schema.TaggedStruct("And", { conditions: Schema.Array(Recursive) }),
-	Schema.TaggedStruct("Or", { conditions: Schema.Array(Recursive) }),
-	Schema.TaggedStruct("Not", { condition: Recursive })
-]);
+const satisfiable = (condition, options = {}) => satisfiable$1(nodeOf(condition), kindsIn(options.schema === void 0 ? void 0 : catalogOf(options.schema.ast)), options.budget);
 /**
 * The Schema of a condition with no predicate. It checks the shape only. Use
 * `Policy.schema` to check the field names against a domain too.
 *
+* The decoder takes at most 500 levels of conditions, and at most 1000000
+* objects and array items, with a shared object counted for each place. It
+* reads only the own data fields of the input.
+*
 * @stability stable
 * @category schemas
 * @since 0.3.0
 */
-const schema = Schema.declare((input) => typeof input === "object" && input !== null).pipe(Schema.check(Schema.makeFilter(fitsLimits)), Schema.decodeTo(shape, SchemaTransformation.passthrough()), Schema.decodeTo(Schema.declare((input) => isPlainNode(input, /* @__PURE__ */ new Map(), 0)), SchemaTransformation.transformEffect({
-	decode: (condition) => Effect.succeed(condition),
-	encode: (condition, options) => jsonSize(condition, /* @__PURE__ */ new Map()) > maxJsonNodes ? Effect.fail(new SchemaIssue.InvalidValue({ message: `The JSON form of this condition would have more than ${String(maxJsonNodes)} nodes` }, condition, options)) : Effect.succeed(condition)
+const schema = Schema.Unknown.pipe(Schema.decodeTo(Schema.declare((input) => isNode(input) && !input.opaque), SchemaTransformation.transformEffect({
+	decode: (input, options) => Result.match(decode(input), {
+		onSuccess: (node) => Effect.succeed(node),
+		onFailure: (problem) => Effect.fail(new SchemaIssue.Pointer(problem.path, new SchemaIssue.InvalidValue({ message: problem.message }, input, options)))
+	}),
+	encode: (condition) => Effect.sync(() => toJson(condition))
 })));
-const compareOperators = HashSet.make("eq", "ne", "lt", "lte", "gt", "gte");
-/**
-* Tests if a value is an operand. With `json`, its number must be finite, as
-* the JSON form holds only such numbers.
-*/
-const isOperandValue = (operand, json) => hasProperty(operand, "_tag") && (operand._tag === "Principal" ? hasProperty(operand, "path") && typeof operand.path === "string" : operand._tag === "Literal" && hasProperty(operand, "value") && (operand.value === null || typeof operand.value === "string" || typeof operand.value === "boolean" || typeof operand.value === "number" && (!json || Number.isFinite(operand.value))));
-const isOperandList = (values, json) => Array.isArray(values) && Arr.every(values, (operand) => isOperandValue(operand, json));
-/**
-* Tests if a value is a whole condition with no predicate, as the JSON form
-* holds it. A shared node is tested one time. A node deeper than
-* `maxJsonDepth` is not taken, so the walk does not fill the stack.
-*/
-const isPlainNode = (input, memo, depth, predicates = false) => depth <= maxJsonDepth && hasProperty(input, "_tag") && remember(memo, input, () => {
-	const child = (node) => isPlainNode(node, memo, depth + 1, predicates);
-	switch (input._tag) {
-		case "Predicate": return predicates && hasProperty(input, "name") && typeof input.name === "string" && hasProperty(input, "run") && typeof input.run === "function";
-		case "True":
-		case "False": return true;
-		case "Compare": return hasProperty(input, "op") && typeof input.op === "string" && HashSet.has(compareOperators, input.op) && hasProperty(input, "field") && typeof input.field === "string" && hasProperty(input, "value") && isOperandValue(input.value, !predicates);
-		case "In": return hasProperty(input, "field") && typeof input.field === "string" && hasProperty(input, "values") && isOperandList(input.values, !predicates);
-		case "Exists": return hasProperty(input, "field") && typeof input.field === "string";
-		case "Under": return hasProperty(input, "prefix") && isOperandList(input.prefix, !predicates);
-		case "And":
-		case "Or": return hasProperty(input, "conditions") && Array.isArray(input.conditions) && Arr.every(input.conditions, child);
-		case "Not": return hasProperty(input, "condition") && child(input.condition);
-		default: return false;
-	}
-});
-/**
-* Tests if a value is a whole condition tree: each node has a known tag and
-* the fields of that tag. A predicate node needs a name and a test. A tree
-* deeper than 1000 levels is not taken.
-*
-* @stability stable
-* @category guards
-* @since 1.0.0
-*/
-const isAst = (u) => isPlainNode(u, /* @__PURE__ */ new Map(), 0, true);
-/** The most nodes of the JSON form of a condition. */
-const maxJsonNodes = 1e5;
-/**
-* The number of nodes of the JSON form of a condition. A shared child counts
-* one time for each place.
-*/
-const jsonSize = (ast, memo) => remember(memo, ast, () => {
-	switch (ast._tag) {
-		case "And":
-		case "Or": return Arr.reduce(ast.conditions, 1, (size, child) => size + jsonSize(child, memo));
-		case "Not": return 1 + jsonSize(ast.condition, memo);
-		default: return 1;
-	}
-});
-export { Condition_exports, Untranslatable, always, and, andAll, builder, evaluate, evaluateSync, fields, fold, hasPredicate, isAst, never, not, or, orAll, partial, provideContext, satisfiable, schema, simplifier, simplify, toJsonValue };
+export { Condition_exports, Untranslatable, always, and, andAll, builder, evaluate, evaluateSync, fields, fold, never, not, or, orAll, partial, provideContext, satisfiable, schema, simplify };
 
 //# sourceMappingURL=Condition.js.map