@nmnmcc/ability 0.2.0 → 1.0.0

package/dist/Condition.js

@@ -0,0 +1,1123 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { anyDomain, domainOf, hasNoValue, hasValue, isPlainField } from "./Resource.js";
+import * as Arr from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as Data from "effect/Data";
+import { dual } from "effect/Function";
+import * as HashMap from "effect/HashMap";
+import * as HashSet from "effect/HashSet";
+import { hasProperty, isObject } from "effect/Predicate";
+import * as SchemaIssue from "effect/SchemaIssue";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+// src/Condition.ts
+/**
+* A condition is a test on a resource value. A rule applies only when its
+* condition is true.
+*
+* A condition is plain data: a tree of nodes. So you can:
+* - test it on a value with {@link evaluate};
+* - put the principal into it and make it smaller with {@link partial}, which
+*   gives a "residual" condition: the part that still depends on the
+*   resource;
+* - change it into a database query with {@link fold};
+* - keep it as JSON with {@link schema}.
+*
+* Make conditions with a {@link Builder}. A rule gives you a builder for its
+* resource, so the field names and the value types are checked.
+*
+* {@link Builder.predicate} is the one way out of plain data. A predicate runs
+* any `Effect`. Its error type and its service type go into the type of the
+* check. A rule with a predicate can not become JSON, and the type system
+* stops you when you try.
+*
+* @stability stable
+* @since 0.3.0
+*/
+var Condition_exports = /* @__PURE__ */ __exportAll({
+	Untranslatable: () => Untranslatable,
+	always: () => always,
+	and: () => and,
+	andAll: () => andAll,
+	builder: () => builder,
+	evaluate: () => evaluate,
+	evaluateSync: () => evaluateSync,
+	fields: () => fields,
+	fold: () => fold,
+	hasPredicate: () => hasPredicate,
+	isAst: () => isAst,
+	never: () => never,
+	not: () => not,
+	or: () => or,
+	orAll: () => orAll,
+	partial: () => partial,
+	provideContext: () => provideContext,
+	satisfiable: () => satisfiable,
+	schema: () => schema,
+	simplifier: () => simplifier,
+	simplify: () => simplify,
+	toJsonValue: () => toJsonValue
+});
+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({
+	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 sharedBuilder = {
+	eq: compare("eq"),
+	ne: compare("ne"),
+	lt: compare("lt"),
+	lte: compare("lte"),
+	gt: compare("gt"),
+	gte: compare("gte"),
+	in: (field, values) => nodes.In({
+		field,
+		values: values.map(toOperand)
+	}),
+	exists: (field) => nodes.Exists({ field }),
+	under: (...prefix) => nodes.Under({ prefix: prefix.map(toOperand) }),
+	principal: (path) => operands.Principal({ path }),
+	and: makeAnd,
+	or: makeOr,
+	not: makeNot,
+	predicate: (name, test) => makePredicate(name, (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
+* often need this.
+*
+* @stability stable
+* @category constructors
+* @since 0.3.0
+*/
+const builder = () => sharedBuilder;
+/**
+* Always true.
+*
+* @stability stable
+* @category constructors
+* @since 0.3.0
+*/
+const always = nodes.True();
+/**
+* Always false.
+*
+* @stability stable
+* @category constructors
+* @since 0.3.0
+*/
+const never = nodes.False();
+/**
+* True when all the conditions are true. With no conditions, it is true.
+*
+* @stability stable
+* @category combinators
+* @since 0.3.0
+*/
+const and = makeAnd;
+/**
+* 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.
+*
+* @stability stable
+* @category combinators
+* @since 1.0.0
+*/
+const andAll = andOf;
+/**
+* The same as {@link or}, for a list of conditions of one type. Use it for a
+* long list: a function call may take only so many arguments.
+*
+* @stability stable
+* @category combinators
+* @since 1.0.0
+*/
+const orAll = orOf;
+/**
+* True when one of the conditions is true. With no conditions, it is false.
+*
+* @stability stable
+* @category combinators
+* @since 0.3.0
+*/
+const or = makeOr;
+/**
+* @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 the services in `context` to every predicate of a condition, so the
+* condition needs no services when it runs.
+*
+* @stability stable
+* @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));
+	}
+};
+/**
+* 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
+* that the predicate reads.
+*
+* @stability stable
+* @category evaluation
+* @since 0.3.0
+*/
+const evaluate = dual(2, evaluateAst);
+/**
+* Tests a condition with no predicate on a value, at once.
+*
+* @stability stable
+* @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());
+/**
+* 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.
+*
+* @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;
+	}
+};
+/**
+* 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
+* `Under` nodes. It is `True` or `False` when the answer does not depend on the
+* resource value.
+*
+* @stability stable
+* @category evaluation
+* @since 0.3.0
+*/
+const partial = dual(2, (ast, input) => simplifyAst(bind(ast, input.principal, input.path)));
+/**
+* The error when `fold` can not change a node.
+*
+* @stability stable
+* @category errors
+* @since 0.3.0
+*/
+var Untranslatable = class extends Schema.TaggedError("@nmnmcc/ability/Condition/Untranslatable")("Untranslatable", { reason: Schema.String }) {};
+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) {
+		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 "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 "Predicate":
+			if (interpreter.predicate === void 0) throw Untranslatable.make({ reason: `The predicate "${ast.name}" can not become a query` });
+			return interpreter.predicate(ast.name);
+	}
+};
+/**
+* Changes a condition into another form with an interpreter. Call
+* {@link partial} first: `fold` fails on principal fields and on `Under`
+* nodes, and on predicates when the interpreter has no `predicate` function.
+*
+* @stability stable
+* @category converting
+* @since 0.3.0
+*/
+const fold = dual(2, (ast, interpreter) => Effect.try({
+	try: () => foldAst(ast, interpreter),
+	catch: (cause) => {
+		if (cause instanceof Untranslatable) return cause;
+		throw cause;
+	}
+}));
+/**
+* The fields that a condition uses.
+*
+* @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;
+	}
+};
+/**
+* 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.
+*
+* 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 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.
+*
+* @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 })
+]);
+/**
+* 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.
+*
+* @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 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 };
+
+//# sourceMappingURL=Condition.js.map