@nmnmcc/ability 1.0.0 → 2.0.0

package/dist/internal/json.js

@@ -0,0 +1,134 @@
+import { LimitExceeded, jsonNodes } from "./limits.js";
+import { And, Compare, Exists, In, Not, Or, Under, always, isScalar, literal, never, principalRef, toJson as toJson$1 } from "./nodes.js";
+import { readPart } from "./read.js";
+import * as Result from "effect/Result";
+import * as Data from "effect/Data";
+import * as Arr from "effect/Array";
+// src/internal/json.ts
+/**
+* The JSON form of a condition. The decoder is a plain walk with two limits:
+* it goes at most `conditionDepth` levels down, and it reads at most
+* `jsonNodes` objects and array items, with a shared object counted for each
+* place. So no input can fill the stack or take a very long time. It makes
+* each node with its constructor, and it reads only the own data fields of
+* the input, as a condition reads a value.
+*/
+/** Gives the JSON form of a condition with no predicate. See `Nodes.toJson`. */
+const toJson = (node) => toJson$1(node);
+/** A problem of an input, with the path of the problem. */
+var Problem = class extends Data.TaggedError("Problem") {};
+const problem = (path, message) => new Problem({
+	path,
+	message
+});
+/** Counts `count` more objects or items, and stops past the limit. */
+const spend = (budget, count, path) => {
+	budget.used += count;
+	if (budget.used > 1e6) throw problem(path, `The input has more than ${String(jsonNodes)} objects and items. The most is ${String(jsonNodes)}.`);
+};
+/** Reads a field of the input. A field that is not plain data is a problem. */
+const read = (input, name, path) => {
+	try {
+		return readPart(input, name);
+	} catch {
+		throw problem([...path, name], `The field "${name}" is not plain data`);
+	}
+};
+const readString = (input, name, path) => {
+	const value = read(input, name, path);
+	if (typeof value !== "string") throw problem([...path, name], `The field "${name}" must be a string`);
+	return value;
+};
+/** Reads the items of an array. */
+const readList = (input, name, path, budget) => {
+	const value = read(input, name, path);
+	const at = [...path, name];
+	if (!Array.isArray(value)) throw problem(at, `The field "${name}" must be an array`);
+	const list = value;
+	spend(budget, list.length, at);
+	return Array.from({ length: list.length }, (_, index) => read(list, String(index), at));
+};
+const isJsonScalar = (value) => isScalar(value) && (typeof value !== "number" || Number.isFinite(value));
+const decodeOperand = (input, path) => {
+	const tag = read(input, "_tag", path);
+	if (tag === "Literal") {
+		const own = typeof input === "object" && input !== null ? Object.getOwnPropertyDescriptor(input, "value") : void 0;
+		if (own === void 0 || "value" in own && own.value === void 0) throw problem([...path, "value"], "A fixed value is missing");
+		const value = read(input, "value", path);
+		if (!isJsonScalar(value)) throw problem([...path, "value"], "A fixed value must be a string, a finite number, a boolean or null");
+		return literal(value);
+	}
+	if (tag === "Principal") return principalRef(readString(input, "path", path));
+	throw problem([...path, "_tag"], "An operand must have the tag \"Literal\" or \"Principal\"");
+};
+const decodeOperands = (input, name, path, budget) => Arr.map(readList(input, name, path, budget), (operand, index) => decodeOperand(operand, [
+	...path,
+	name,
+	index
+]));
+const compareOperators = [
+	"eq",
+	"ne",
+	"lt",
+	"lte",
+	"gt",
+	"gte"
+];
+const decodeNode = (input, path, depth, budget) => {
+	if (depth > 500) throw problem(path, `A condition has more than ${String(500)} levels. The most is ${String(500)}.`);
+	if (typeof input !== "object" || input === null) throw problem(path, "A condition node must be an object");
+	spend(budget, 1, path);
+	const children = (name) => Arr.map(readList(input, name, path, budget), (child, index) => decodeNode(child, [
+		...path,
+		name,
+		index
+	], depth + 1, budget));
+	try {
+		return makeNode(input, path, depth, budget, children);
+	} catch (error) {
+		if (error instanceof LimitExceeded) throw problem(path, error.message);
+		throw error;
+	}
+};
+const makeNode = (input, path, depth, budget, children) => {
+	switch (read(input, "_tag", path)) {
+		case "True": return always;
+		case "False": return never;
+		case "Compare": {
+			const op = readString(input, "op", path);
+			if (!compareOperators.includes(op)) throw problem([...path, "op"], `"${op}" is not a compare operator`);
+			return new Compare({
+				op,
+				field: readString(input, "field", path),
+				value: decodeOperand(read(input, "value", path), [...path, "value"])
+			});
+		}
+		case "In": return new In({
+			field: readString(input, "field", path),
+			values: decodeOperands(input, "values", path, budget)
+		});
+		case "Exists": return new Exists({ field: readString(input, "field", path) });
+		case "Under": return new Under({ prefix: decodeOperands(input, "prefix", path, budget) });
+		case "And": return new And(children("conditions"));
+		case "Or": return new Or(children("conditions"));
+		case "Not": return new Not(decodeNode(read(input, "condition", path), [...path, "condition"], depth + 1, budget));
+		default: throw problem([...path, "_tag"], "The node has no known tag");
+	}
+};
+/**
+* Decodes the JSON form of a condition at a path, with the budget of a larger
+* decode. It throws a {@link Problem}.
+*/
+const decodeAt = (input, path, budget) => decodeNode(input, path, 1, budget);
+/** Decodes the JSON form of a condition. */
+const decode = (input) => {
+	try {
+		return Result.succeed(decodeNode(input, [], 1, { used: 0 }));
+	} catch (error) {
+		if (error instanceof Problem) return Result.fail(error);
+		throw error;
+	}
+};
+export { Problem, decode, decodeAt, problem, read, readList, readString, spend, toJson };
+
+//# sourceMappingURL=json.js.map

package/dist/internal/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","names":["Nodes.toJson","Limits.jsonNodes","Nodes.isScalar","Nodes.literal","Nodes.principalRef","Limits.LimitExceeded","Nodes.always","Nodes.never","Nodes.Compare","Nodes.In","Nodes.Exists","Nodes.Under","Nodes.And","Nodes.Or","Nodes.Not"],"sources":["../../src/internal/json.ts"],"sourcesContent":["/**\n * The JSON form of a condition. The decoder is a plain walk with two limits:\n * it goes at most `conditionDepth` levels down, and it reads at most\n * `jsonNodes` objects and array items, with a shared object counted for each\n * place. So no input can fill the stack or take a very long time. It makes\n * each node with its constructor, and it reads only the own data fields of\n * the input, as a condition reads a value.\n */\nimport * as Arr from \"effect/Array\"\nimport * as Data from \"effect/Data\"\nimport * as Result from \"effect/Result\"\nimport type * as SchemaIssue from \"effect/SchemaIssue\"\nimport * as Limits from \"./limits.ts\"\nimport * as Nodes from \"./nodes.ts\"\nimport { readPart } from \"./read.ts\"\n\ntype Node = Nodes.Node\n\n/** Gives the JSON form of a condition with no predicate. See `Nodes.toJson`. */\nexport const toJson = (node: Node): unknown => Nodes.toJson(node)\n\n/** A problem of an input, with the path of the problem. */\nexport class Problem extends Data.TaggedError(\"Problem\")<{\n\treadonly path: ReadonlyArray<PropertyKey>\n\treadonly message: string\n\t/** The issue of a Schema that the decode used, as for `meta`. */\n\treadonly issue?: SchemaIssue.Issue | undefined\n}> {}\n\n/** The count of the objects and items that one decode has read. It belongs to one decode. */\nexport interface Budget {\n\tused: number\n}\n\nexport const problem = (path: ReadonlyArray<PropertyKey>, message: string) =>\n\tnew Problem({ path, message })\n\n/** Counts `count` more objects or items, and stops past the limit. */\nexport const spend = (\n\tbudget: Budget,\n\tcount: number,\n\tpath: ReadonlyArray<PropertyKey>,\n): void => {\n\tbudget.used += count\n\tif (budget.used > Limits.jsonNodes) {\n\t\tthrow problem(\n\t\t\tpath,\n\t\t\t`The input has more than ${String(Limits.jsonNodes)} objects and items. The most is ${String(Limits.jsonNodes)}.`,\n\t\t)\n\t}\n}\n\n/** Reads a field of the input. A field that is not plain data is a problem. */\nexport const read = (\n\tinput: unknown,\n\tname: string,\n\tpath: ReadonlyArray<PropertyKey>,\n): unknown => {\n\ttry {\n\t\treturn readPart(input, name)\n\t} catch {\n\t\tthrow problem([...path, name], `The field \"${name}\" is not plain data`)\n\t}\n}\n\nexport const readString = (\n\tinput: unknown,\n\tname: string,\n\tpath: ReadonlyArray<PropertyKey>,\n): string => {\n\tconst value = read(input, name, path)\n\tif (typeof value !== \"string\") {\n\t\tthrow problem([...path, name], `The field \"${name}\" must be a string`)\n\t}\n\treturn value\n}\n\n/** Reads the items of an array. */\nexport const readList = (\n\tinput: unknown,\n\tname: string,\n\tpath: ReadonlyArray<PropertyKey>,\n\tbudget: Budget,\n): ReadonlyArray<unknown> => {\n\tconst value = read(input, name, path)\n\tconst at = [...path, name]\n\tif (!Array.isArray(value)) {\n\t\tthrow problem(at, `The field \"${name}\" must be an array`)\n\t}\n\tconst list: ReadonlyArray<unknown> = value\n\tspend(budget, list.length, at)\n\t// `Array.makeBy` of Effect gives at least one item, so it can not make an\n\t// empty list. An array-like object with a length makes one with no read\n\t// of the items before the read rule.\n\treturn Array.from({ length: list.length }, (_, index) =>\n\t\tread(list, String(index), at),\n\t)\n}\n\nconst isJsonScalar = (value: unknown): value is Nodes.Scalar =>\n\tNodes.isScalar(value) && (typeof value !== \"number\" || Number.isFinite(value))\n\nconst decodeOperand = (\n\tinput: unknown,\n\tpath: ReadonlyArray<PropertyKey>,\n): Nodes.Operand => {\n\tconst tag = read(input, \"_tag\", path)\n\tif (tag === \"Literal\") {\n\t\t// A missing value is not `null`: a test with `null` has its own\n\t\t// meaning, and a lost value must not become one.\n\t\tconst own =\n\t\t\ttypeof input === \"object\" && input !== null\n\t\t\t\t? Object.getOwnPropertyDescriptor(input, \"value\")\n\t\t\t\t: undefined\n\t\tif (own === undefined || (\"value\" in own && own.value === undefined)) {\n\t\t\tthrow problem([...path, \"value\"], \"A fixed value is missing\")\n\t\t}\n\t\tconst value = read(input, \"value\", path)\n\t\tif (!isJsonScalar(value)) {\n\t\t\tthrow problem(\n\t\t\t\t[...path, \"value\"],\n\t\t\t\t\"A fixed value must be a string, a finite number, a boolean or null\",\n\t\t\t)\n\t\t}\n\t\treturn Nodes.literal(value)\n\t}\n\tif (tag === \"Principal\") {\n\t\treturn Nodes.principalRef(readString(input, \"path\", path))\n\t}\n\tthrow problem(\n\t\t[...path, \"_tag\"],\n\t\t'An operand must have the tag \"Literal\" or \"Principal\"',\n\t)\n}\n\nconst decodeOperands = (\n\tinput: unknown,\n\tname: string,\n\tpath: ReadonlyArray<PropertyKey>,\n\tbudget: Budget,\n): ReadonlyArray<Nodes.Operand> =>\n\tArr.map(readList(input, name, path, budget), (operand, index) =>\n\t\tdecodeOperand(operand, [...path, name, index]),\n\t)\n\nconst compareOperators: ReadonlyArray<string> = [\n\t\"eq\",\n\t\"ne\",\n\t\"lt\",\n\t\"lte\",\n\t\"gt\",\n\t\"gte\",\n]\n\nconst decodeNode = (\n\tinput: unknown,\n\tpath: ReadonlyArray<PropertyKey>,\n\tdepth: number,\n\tbudget: Budget,\n): Node => {\n\tif (depth > Limits.conditionDepth) {\n\t\tthrow problem(\n\t\t\tpath,\n\t\t\t`A condition has more than ${String(Limits.conditionDepth)} levels. The most is ${String(Limits.conditionDepth)}.`,\n\t\t)\n\t}\n\tif (typeof input !== \"object\" || input === null) {\n\t\tthrow problem(path, \"A condition node must be an object\")\n\t}\n\tspend(budget, 1, path)\n\tconst children = (name: string) =>\n\t\tArr.map(readList(input, name, path, budget), (child, index) =>\n\t\t\tdecodeNode(child, [...path, name, index], depth + 1, budget),\n\t\t)\n\ttry {\n\t\treturn makeNode(input, path, depth, budget, children)\n\t} catch (error) {\n\t\t// A node past a limit, such as a field path with too many parts, is a\n\t\t// problem at its place.\n\t\tif (error instanceof Limits.LimitExceeded) {\n\t\t\tthrow problem(path, error.message)\n\t\t}\n\t\tthrow error\n\t}\n}\n\nconst makeNode = (\n\tinput: object,\n\tpath: ReadonlyArray<PropertyKey>,\n\tdepth: number,\n\tbudget: Budget,\n\tchildren: (name: string) => ReadonlyArray<Node>,\n): Node => {\n\tconst tag = read(input, \"_tag\", path)\n\tswitch (tag) {\n\t\tcase \"True\":\n\t\t\treturn Nodes.always\n\t\tcase \"False\":\n\t\t\treturn Nodes.never\n\t\tcase \"Compare\": {\n\t\t\tconst op = readString(input, \"op\", path)\n\t\t\tif (!compareOperators.includes(op)) {\n\t\t\t\tthrow problem([...path, \"op\"], `\"${op}\" is not a compare operator`)\n\t\t\t}\n\t\t\treturn new Nodes.Compare({\n\t\t\t\top: op as Nodes.CompareOperator,\n\t\t\t\tfield: readString(input, \"field\", path),\n\t\t\t\tvalue: decodeOperand(read(input, \"value\", path), [...path, \"value\"]),\n\t\t\t})\n\t\t}\n\t\tcase \"In\":\n\t\t\treturn new Nodes.In({\n\t\t\t\tfield: readString(input, \"field\", path),\n\t\t\t\tvalues: decodeOperands(input, \"values\", path, budget),\n\t\t\t})\n\t\tcase \"Exists\":\n\t\t\treturn new Nodes.Exists({ field: readString(input, \"field\", path) })\n\t\tcase \"Under\":\n\t\t\treturn new Nodes.Under({\n\t\t\t\tprefix: decodeOperands(input, \"prefix\", path, budget),\n\t\t\t})\n\t\tcase \"And\":\n\t\t\treturn new Nodes.And(children(\"conditions\"))\n\t\tcase \"Or\":\n\t\t\treturn new Nodes.Or(children(\"conditions\"))\n\t\tcase \"Not\":\n\t\t\treturn new Nodes.Not(\n\t\t\t\tdecodeNode(\n\t\t\t\t\tread(input, \"condition\", path),\n\t\t\t\t\t[...path, \"condition\"],\n\t\t\t\t\tdepth + 1,\n\t\t\t\t\tbudget,\n\t\t\t\t),\n\t\t\t)\n\t\tdefault:\n\t\t\tthrow problem([...path, \"_tag\"], \"The node has no known tag\")\n\t}\n}\n\n/**\n * Decodes the JSON form of a condition at a path, with the budget of a larger\n * decode. It throws a {@link Problem}.\n */\nexport const decodeAt = (\n\tinput: unknown,\n\tpath: ReadonlyArray<PropertyKey>,\n\tbudget: Budget,\n): Node => decodeNode(input, path, 1, budget)\n\n/** Decodes the JSON form of a condition. */\nexport const decode = (input: unknown): Result.Result<Node, Problem> => {\n\ttry {\n\t\treturn Result.succeed(decodeNode(input, [], 1, { used: 0 }))\n\t} catch (error) {\n\t\tif (error instanceof Problem) {\n\t\t\treturn Result.fail(error)\n\t\t}\n\t\tthrow error\n\t}\n}\n"],"mappings":"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"}

package/dist/internal/limits.d.ts

@@ -0,0 +1,14 @@
+import * as Schema from "effect/Schema";
+declare const LimitExceeded_base: Schema.Class<LimitExceeded, Schema.TaggedStruct<"LimitExceeded", {
+  readonly limit: Schema.String;
+  readonly size: Schema.Finite;
+  readonly max: Schema.Finite;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The error when an input goes past a limit. It names the limit, the size of
+ * the input, and the most that the limit takes.
+ */
+export declare class LimitExceeded extends LimitExceeded_base {}
+export {};
+//# sourceMappingURL=limits.d.ts.map

package/dist/internal/limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limits.d.ts","names":[],"sources":["../../src/internal/limits.ts"],"mappings":";;;;;;;;;;;qBAoDa,sBAAsB"}

package/dist/internal/limits.js

@@ -0,0 +1,43 @@
+import * as Schema from "effect/Schema";
+/**
+* The most nodes of one condition. A child that a condition uses in many
+* places is counted for each place.
+*/
+const conditionNodes = 1e5;
+/** The most nodes of one residual condition. */
+const residualNodes = 1e4;
+/**
+* The most nodes of a policy tree, with its rules and the nodes of their
+* conditions. A part that the tree uses in many places is counted for each
+* place.
+*/
+const policyNodes = 1e5;
+/** The most objects and arrays in one input to a decoder. */
+const jsonNodes = 1e6;
+/** The most fields in the catalog of one Schema. */
+const catalogFields = 1e4;
+/** The most steps of one search for a value. */
+const searchSteps = 1e6;
+/**
+* The error when an input goes past a limit. It names the limit, the size of
+* the input, and the most that the limit takes.
+*/
+var LimitExceeded = class extends Schema.TaggedError("@nmnmcc/ability/Limits/LimitExceeded")("LimitExceeded", {
+	limit: Schema.String,
+	size: Schema.Finite,
+	max: Schema.Finite,
+	message: Schema.String
+}) {};
+/**
+* Makes the error for a limit, with one form of message for every limit, as
+* in "A condition has 100001 nodes. The most is 100000."
+*/
+const exceeded = (thing, limit, unit, size, max) => LimitExceeded.make({
+	limit,
+	size,
+	max,
+	message: `${thing} has ${String(size)} ${unit}. The most is ${String(max)}.`
+});
+export { LimitExceeded, catalogFields, conditionNodes, exceeded, jsonNodes, policyNodes, residualNodes, searchSteps };
+
+//# sourceMappingURL=limits.js.map

package/dist/internal/limits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"limits.js","names":[],"sources":["../../src/internal/limits.ts"],"sourcesContent":["/**\n * The one table of limits. Each limit keeps a walk, a decoder or a search\n * bounded, so no input can fill the stack or take a very long time. The\n * values are the same in the types and at run time where both have one, as\n * for the parts of a field path.\n */\nimport * as Schema from \"effect/Schema\"\n\n/** The most parts of a field path, as in `settings.model`. */\nexport const fieldPathParts = 5\n\n/** The most parts of a field pattern, as in `**.secret`. */\nexport const patternParts = 16\n\n/**\n * The most nodes of one condition. A child that a condition uses in many\n * places is counted for each place.\n */\nexport const conditionNodes = 100_000\n\n/** The most levels of one condition. */\nexport const conditionDepth = 500\n\n/** The most nodes of one residual condition. */\nexport const residualNodes = 10_000\n\n/** The most levels of a policy tree. */\nexport const policyDepth = 256\n\n/**\n * The most nodes of a policy tree, with its rules and the nodes of their\n * conditions. A part that the tree uses in many places is counted for each\n * place.\n */\nexport const policyNodes = 100_000\n\n/** The most objects and arrays in one input to a decoder. */\nexport const jsonNodes = 1_000_000\n\n/** The most fields in the catalog of one Schema. */\nexport const catalogFields = 10_000\n\n/** The most steps of one search for a value. */\nexport const searchSteps = 1_000_000\n\n/** The most fields that one search for a value may test. */\nexport const searchFields = 256\n\n/**\n * The error when an input goes past a limit. It names the limit, the size of\n * the input, and the most that the limit takes.\n */\nexport class LimitExceeded extends Schema.TaggedError<LimitExceeded>(\n\t\"@nmnmcc/ability/Limits/LimitExceeded\",\n)(\"LimitExceeded\", {\n\tlimit: Schema.String,\n\tsize: Schema.Finite,\n\tmax: Schema.Finite,\n\tmessage: Schema.String,\n}) {}\n\n/**\n * Makes the error for a limit, with one form of message for every limit, as\n * in \"A condition has 100001 nodes. The most is 100000.\"\n */\nexport const exceeded = (\n\tthing: string,\n\tlimit: string,\n\tunit: string,\n\tsize: number,\n\tmax: number,\n): LimitExceeded =>\n\tLimitExceeded.make({\n\t\tlimit,\n\t\tsize,\n\t\tmax,\n\t\tmessage: `${thing} has ${String(size)} ${unit}. The most is ${String(max)}.`,\n\t})\n"],"mappings":";;;;;AAkBA,MAAa,iBAAiB;;AAM9B,MAAa,gBAAgB;;;;;;AAU7B,MAAa,cAAc;;AAG3B,MAAa,YAAY;;AAGzB,MAAa,gBAAgB;;AAG7B,MAAa,cAAc;;;;;AAS3B,IAAa,gBAAb,cAAmC,OAAO,YACzC,sCACD,CAAC,CAAC,iBAAiB;CAClB,OAAO,OAAO;CACd,MAAM,OAAO;CACb,KAAK,OAAO;CACZ,SAAS,OAAO;AACjB,CAAC,CAAC,CAAC,CAAC;;;;;AAMJ,MAAa,YACZ,OACA,OACA,MACA,MACA,QAEA,cAAc,KAAK;CAClB;CACA;CACA;CACA,SAAS,GAAG,MAAM,OAAO,OAAO,IAAI,EAAE,GAAG,KAAK,gBAAgB,OAAO,GAAG,EAAE;AAC3E,CAAC"}

package/dist/internal/nodes.d.ts

@@ -0,0 +1,121 @@
+import * as Effect from "effect/Effect";
+import * as Data from "effect/Data";
+/** A value that a condition can compare. */
+export type Scalar = string | number | boolean | null;
+export type CompareOperator = "eq" | "ne" | "lt" | "lte" | "gt" | "gte";
+/** A fixed value. */
+export interface Literal {
+  readonly _tag: "Literal";
+  readonly value: Scalar;
+}
+/** A field of the principal. */
+export interface PrincipalRef {
+  readonly _tag: "Principal";
+  readonly path: string;
+}
+export type Operand = Literal | PrincipalRef;
+interface Facts {
+  readonly size: number;
+  readonly depth: number;
+  readonly opaque: boolean;
+}
+/** The base of every node. It keeps the facts. */
+declare abstract class Base extends Data.Class {
+  #private;
+  /**
+   * The JSON form of the node, for `JSON.stringify`. A number that JSON can
+   * not hold, as `Infinity`, becomes an object that no decoder takes, in
+   * place of `null`, which would change the test.
+   */
+  toJSON(): unknown;
+  constructor(props: object, facts: Facts);
+  /** The number of nodes, with a shared child counted for each place. */
+  get size(): number;
+  /** The number of levels. */
+  get depth(): number;
+  /** The node has a predicate. */
+  get opaque(): boolean;
+}
+/** Always true. */
+export declare class True extends Base {
+  readonly _tag = "True";
+  constructor();
+}
+/** Always false. */
+export declare class False extends Base {
+  readonly _tag = "False";
+  constructor();
+}
+/** Compares a field with a value. */
+export declare class Compare extends Base {
+  readonly _tag = "Compare";
+  readonly op: CompareOperator;
+  readonly field: string;
+  readonly value: Operand;
+  constructor(props: {
+    readonly op: CompareOperator;
+    readonly field: string;
+    readonly value: Operand;
+  });
+}
+/** True when a field is equal to one of the values. */
+export declare class In extends Base {
+  readonly _tag = "In";
+  readonly field: string;
+  readonly values: ReadonlyArray<Operand>;
+  constructor(props: {
+    readonly field: string;
+    readonly values: ReadonlyArray<Operand>;
+  });
+}
+/** True when a field is not `null` and not missing. */
+export declare class Exists extends Base {
+  readonly _tag = "Exists";
+  readonly field: string;
+  constructor(props: {
+    readonly field: string;
+  });
+}
+/** True when the path of the resource starts with the prefix. */
+export declare class Under extends Base {
+  readonly _tag = "Under";
+  readonly prefix: ReadonlyArray<Operand>;
+  constructor(props: {
+    readonly prefix: ReadonlyArray<Operand>;
+  });
+}
+export declare class And extends Base {
+  readonly _tag = "And";
+  readonly conditions: ReadonlyArray<Node>;
+  constructor(conditions: ReadonlyArray<Node>);
+}
+export declare class Or extends Base {
+  readonly _tag = "Or";
+  readonly conditions: ReadonlyArray<Node>;
+  constructor(conditions: ReadonlyArray<Node>);
+}
+export declare class Not extends Base {
+  readonly _tag = "Not";
+  readonly condition: Node;
+  constructor(condition: Node);
+}
+/** The test of a predicate, with no types. */
+export type Run = (value: unknown, principal: unknown) => Effect.Effect<boolean, unknown, unknown>;
+/**
+ * A test that runs an `Effect`. Its test takes inputs of the type `never`, so
+ * no code can call it with a value of the wrong type: `Condition.evaluate`
+ * checks the input. Use {@link runOf} inside the library.
+ */
+export declare class Predicate extends Base {
+  readonly _tag = "Predicate";
+  readonly name: string;
+  readonly run: (value: never, principal: never) => Effect.Effect<boolean, unknown, unknown>;
+  constructor(props: {
+    readonly name: string;
+    readonly run: Run;
+  });
+}
+/** A node of a condition. */
+export type Node = True | False | Compare | In | Exists | Under | And | Or | Not | Predicate;
+export {};
+//# sourceMappingURL=nodes.d.ts.map

package/dist/internal/nodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodes.d.ts","names":[],"sources":["../../src/internal/nodes.ts"],"mappings":";;;YA0BY;YAEA;;iBAGK;WACP;WACA,OAAO;;;iBAIA;WACP;WACA;;YAGE,UAAU,UAAU;UAwEtB;WACA;WACA;WACA;;;uBAoCK,aAAa,KAAK;;;;;;;EAMhC;EAMA,YAAY,eAAe,OAAO;;MAM9B;;MAKA;;MAKA;;;qBAMQ,aAAa;WAChB;EACT;;;qBAMY,cAAc;WACjB;EACT;;;qBAMY,gBAAgB;WACnB;WACQ,IAAI;WACJ;WACA,OAAO;EACxB,YAAY;aACF,IAAI;aACJ;aACA,OAAO;;;;qBAiBL,WAAW;WACd;WACQ;WACA,QAAQ,cAAc;EACvC,YAAY;aACF;aACA,QAAQ,cAAc;;;;qBAUpB,eAAe;WAClB;WACQ;EACjB,YAAY;aAAkB;;;;qBAMlB,cAAc;WACjB;WACQ,QAAQ,cAAc;EACvC,YAAY;aAAkB,QAAQ,cAAc;;;qBAgBxC,YAAY;WACf;WACQ,YAAY,cAAc;EAC3C,YAAY,YAAY,cAAc;;qBAM1B,WAAW;WACd;WACQ,YAAY,cAAc;EAC3C,YAAY,YAAY,cAAc;;qBAM1B,YAAY;WACf;WACQ,WAAW;EAC5B,YAAY,WAAW;;;YASZ,OACX,gBACA,uBACI,OAAO;;;;;;qBAOC,kBAAkB;WACrB;WACQ;WACA,MAChB,cACA,qBACI,OAAO;EACZ,YAAY;aAAkB;aAAuB,KAAK;;;;YAe/C,OACX,OAAO,QAAQ,UAAU,KAAK,SAAS,QAAQ,MAAM,KAAK,MAAM"}

package/dist/internal/nodes.js

@@ -0,0 +1,277 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { conditionNodes, exceeded } from "./limits.js";
+import * as Data from "effect/Data";
+import * as Arr from "effect/Array";
+import { hasProperty } from "effect/Predicate";
+// src/internal/nodes.ts
+/**
+* The nodes of a condition. Each node is a class, and only its constructor
+* makes one, also when a condition comes from JSON. The constructor checks the
+* data of the node and works out three facts once:
+* - `size`: the number of nodes, with a shared child counted for each place;
+* - `depth`: the number of levels;
+* - `opaque`: the node has a predicate.
+*
+* The constructor stops a node that goes past `conditionNodes` or
+* `conditionDepth`. So a walk over any condition visits at most
+* `conditionNodes` nodes and goes at most `conditionDepth` levels down, and it
+* needs no memo.
+*
+* The facts are private fields, so `Equal` and `Hash` do not read them: two
+* nodes with the same data are equal.
+*/
+var nodes_exports = /* @__PURE__ */ __exportAll({
+	And: () => And,
+	Compare: () => Compare,
+	Exists: () => Exists,
+	False: () => False,
+	In: () => In,
+	Not: () => Not,
+	Or: () => Or,
+	Predicate: () => Predicate,
+	True: () => True,
+	Under: () => Under,
+	always: () => always,
+	isNode: () => isNode,
+	isScalar: () => isScalar,
+	literal: () => literal,
+	never: () => never,
+	principalRef: () => principalRef,
+	runOf: () => runOf,
+	toJson: () => toJson,
+	toNode: () => toNode
+});
+const operands = Data.taggedEnum();
+const literal = (value) => operands.Literal({ value });
+const principalRef = (path) => operands.Principal({ path });
+const compareOperators = [
+	"eq",
+	"ne",
+	"lt",
+	"lte",
+	"gt",
+	"gte"
+];
+/** Tests if a value is a scalar. Any number is one, also `NaN`. */
+const isScalar = (value) => value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+/**
+* Checks a field path: a string with at most `fieldPathParts` parts. A longer
+* path is never a field of a resource or of the principal.
+*/
+const checkPath = (path) => {
+	if (typeof path !== "string") throw new Error("A field path must be a string");
+	const parts = path.split(".", 6).length;
+	if (parts > 5) throw exceeded("A field path", "fieldPathParts", "parts", parts, 5);
+	return path;
+};
+/** Checks an operand, and gives a new one with only its data. */
+const checkOperand = (operand) => {
+	if (hasProperty(operand, "_tag")) {
+		if (operand._tag === "Literal" && hasProperty(operand, "value") && isScalar(operand.value)) return literal(operand.value);
+		if (operand._tag === "Principal" && hasProperty(operand, "path")) return principalRef(checkPath(operand.path));
+	}
+	throw new Error("An operand must be a fixed scalar value or a field of the principal");
+};
+const checkOperands = (values) => {
+	if (!Array.isArray(values)) throw new Error("A list of operands must be an array");
+	return Object.freeze(Arr.map(Array.from(values), checkOperand));
+};
+const leaf = {
+	size: 1,
+	depth: 1,
+	opaque: false
+};
+/** The facts of a node with children. It stops a node past the limits. */
+const factsOf = (children) => {
+	const size = Arr.reduce(children, 1, (total, child) => total + child.size);
+	if (size > 1e5) throw exceeded("A condition", "conditionNodes", "nodes", size, conditionNodes);
+	const depth = 1 + Arr.reduce(children, 0, (top, child) => Math.max(top, child.depth));
+	if (depth > 500) throw exceeded("A condition", "conditionDepth", "levels", depth, 500);
+	return {
+		size,
+		depth,
+		opaque: Arr.some(children, (child) => child.opaque)
+	};
+};
+/** The base of every node. It keeps the facts. */
+var Base = class extends Data.Class {
+	/**
+	* The JSON form of the node, for `JSON.stringify`. A number that JSON can
+	* not hold, as `Infinity`, becomes an object that no decoder takes, in
+	* place of `null`, which would change the test.
+	*/
+	toJSON() {
+		return toJson(this);
+	}
+	#facts;
+	constructor(props, facts) {
+		super(props);
+		this.#facts = facts;
+	}
+	/** The number of nodes, with a shared child counted for each place. */
+	get size() {
+		return this.#facts.size;
+	}
+	/** The number of levels. */
+	get depth() {
+		return this.#facts.depth;
+	}
+	/** The node has a predicate. */
+	get opaque() {
+		return this.#facts.opaque;
+	}
+};
+/** Always true. */
+var True = class extends Base {
+	_tag = "True";
+	constructor() {
+		super({}, leaf);
+	}
+};
+/** Always false. */
+var False = class extends Base {
+	_tag = "False";
+	constructor() {
+		super({}, leaf);
+	}
+};
+/** Compares a field with a value. */
+var Compare = class extends Base {
+	_tag = "Compare";
+	constructor(props) {
+		if (!compareOperators.includes(props.op)) throw new Error(`"${String(props.op)}" is not a compare operator`);
+		super({
+			op: props.op,
+			field: checkPath(props.field),
+			value: checkOperand(props.value)
+		}, leaf);
+	}
+};
+/** True when a field is equal to one of the values. */
+var In = class extends Base {
+	_tag = "In";
+	constructor(props) {
+		super({
+			field: checkPath(props.field),
+			values: checkOperands(props.values)
+		}, leaf);
+	}
+};
+/** True when a field is not `null` and not missing. */
+var Exists = class extends Base {
+	_tag = "Exists";
+	constructor(props) {
+		super({ field: checkPath(props.field) }, leaf);
+	}
+};
+/** True when the path of the resource starts with the prefix. */
+var Under = class extends Base {
+	_tag = "Under";
+	constructor(props) {
+		super({ prefix: checkOperands(props.prefix) }, leaf);
+	}
+};
+const checkChildren = (conditions) => {
+	if (!Array.isArray(conditions)) throw new Error("The children of a node must be an array");
+	const children = Array.from(conditions);
+	if (!Arr.every(children, isNode)) throw notNode();
+	return Object.freeze(children);
+};
+var And = class extends Base {
+	_tag = "And";
+	constructor(conditions) {
+		const children = checkChildren(conditions);
+		super({ conditions: children }, factsOf(children));
+	}
+};
+var Or = class extends Base {
+	_tag = "Or";
+	constructor(conditions) {
+		const children = checkChildren(conditions);
+		super({ conditions: children }, factsOf(children));
+	}
+};
+var Not = class extends Base {
+	_tag = "Not";
+	constructor(condition) {
+		if (!isNode(condition)) throw notNode();
+		super({ condition }, factsOf([condition]));
+	}
+};
+/**
+* A test that runs an `Effect`. Its test takes inputs of the type `never`, so
+* no code can call it with a value of the wrong type: `Condition.evaluate`
+* checks the input. Use {@link runOf} inside the library.
+*/
+var Predicate = class extends Base {
+	_tag = "Predicate";
+	constructor(props) {
+		if (typeof props.name !== "string" || typeof props.run !== "function") throw new Error("A predicate needs a name and a test");
+		super({
+			name: props.name,
+			run: props.run
+		}, {
+			size: 1,
+			depth: 1,
+			opaque: true
+		});
+	}
+};
+/** Gives the test of a predicate, with no types. */
+const runOf = (node) => node.run;
+const operandJson = (operand) => operand._tag === "Literal" ? {
+	_tag: "Literal",
+	value: typeof operand.value === "number" && !Number.isFinite(operand.value) ? { nonFinite: String(operand.value) } : operand.value
+} : {
+	_tag: "Principal",
+	path: operand.path
+};
+/** Gives the JSON form of a condition with no predicate. */
+const toJson = (node) => {
+	switch (node._tag) {
+		case "True":
+		case "False": return { _tag: node._tag };
+		case "Compare": return {
+			_tag: "Compare",
+			op: node.op,
+			field: node.field,
+			value: operandJson(node.value)
+		};
+		case "In": return {
+			_tag: "In",
+			field: node.field,
+			values: Arr.map(node.values, operandJson)
+		};
+		case "Exists": return {
+			_tag: "Exists",
+			field: node.field
+		};
+		case "Under": return {
+			_tag: "Under",
+			prefix: Arr.map(node.prefix, operandJson)
+		};
+		case "And":
+		case "Or": return {
+			_tag: node._tag,
+			conditions: Arr.map(node.conditions, toJson)
+		};
+		case "Not": return {
+			_tag: "Not",
+			condition: toJson(node.condition)
+		};
+		case "Predicate": throw new Error(`The predicate "${node.name}" can not become JSON. A condition with a predicate has no JSON form.`);
+	}
+};
+/** Tests if a value is a node. Only a constructor of a node makes one. */
+const isNode = (u) => u instanceof Base;
+const notNode = () => /* @__PURE__ */ new Error("A condition must be made with a builder or a function of Condition. A plain object is not a condition");
+/** Gives a value as a node, or throws when it is not a node. */
+const toNode = (u) => {
+	if (!isNode(u)) throw notNode();
+	return u;
+};
+const always = new True();
+const never = new False();
+export { And, Compare, Exists, False, In, Not, Or, Predicate, True, Under, always, isNode, isScalar, literal, never, nodes_exports, principalRef, runOf, toJson, toNode };
+
+//# sourceMappingURL=nodes.js.map