@nmnmcc/ability 2.0.6 → 2.0.7

package/src/internal/bind.ts

@@ -252,16 +252,8 @@ const patternIssues = (
 						}) || before
 					)
 				})
-			if (memo.work.steps > Limits.searchSteps && !memo.work.noted) {
-				memo.work.noted = true
-				return [
-					{
-						path: at,
-						issue: `The field patterns of the policy take more than ${String(Limits.searchSteps)} steps to check. The most is ${String(Limits.searchSteps)}.`,
-					},
-				]
-			}
-			return fits
+			// Past the limit of the work, `ruleIssues` gives one issue for it.
+			return fits || memo.work.steps > Limits.searchSteps
 				? []
 				: [
 						{
@@ -314,15 +306,45 @@ const principalField = (
 const isIssue = (value: Catalog.Field | Issue): value is Issue =>
 	"issue" in value
 
-/** The issues of one operand of a test of a field. */
+/**
+ * The fields that a test reads, with one field for each distinct kind of
+ * value. A rule for very many kinds may have one field type in all of them,
+ * so each value of the test is checked one time for each distinct kind, not
+ * one time for each resource. The kinds are found by their text in a native
+ * `Map`, which belongs to this call.
+ */
+const distinctFields = (
+	context: Context,
+	field: string,
+): ReadonlyArray<Catalog.Field> =>
+	Array.from(
+		new Map(
+			Arr.map(
+				fieldsAt(context, field),
+				(found) => [JSON.stringify(found.kinds), found] as const,
+			),
+		).values(),
+	)
+
+/**
+ * Counts the work of the checks of the values of a test, as the work of the
+ * field patterns counts. Past the limit, the values are not checked, and
+ * `ruleIssues` gives one issue for the work.
+ */
+const spendChecks = (memo: Memo, values: number, fields: number): boolean => {
+	memo.work.steps += values * Math.max(fields, 1)
+	return memo.work.steps <= Limits.searchSteps
+}
+
+/** The issues of one operand of a test of a field, with its distinct fields. */
 const operandIssues = (
 	context: Context,
 	field: string,
+	fields: ReadonlyArray<Catalog.Field>,
 	ordered: boolean,
 	operand: Operand,
 	at: ReadonlyArray<PropertyKey>,
 ): ReadonlyArray<Issue> => {
-	const fields = fieldsAt(context, field)
 	if (operand._tag === "Literal") {
 		const value = operand.value
 		if (ordered && typeof value !== "string" && typeof value !== "number") {
@@ -520,8 +542,17 @@ const conditionIssues = (
 	}
 	seen.add(node)
 	const here = (issues: ReadonlyArray<Issue>) => under(context.memo, at, issues)
+	// A test looks its field up in each resource of the rule. A rule for very
+	// many kinds with very many tests is very much work, so it counts. Past
+	// the limit, `ruleIssues` gives one issue for it, and the policy does not
+	// load.
+	const room = (values: number) =>
+		spendChecks(context.memo, 1 + values, context.named.length)
 	switch (node._tag) {
 		case "Compare": {
+			if (!room(1)) {
+				return []
+			}
 			const exists = readIssues(context, node.field, ["field"])
 			return here(
 				exists.length > 0
@@ -529,6 +560,7 @@ const conditionIssues = (
 					: operandIssues(
 							context,
 							node.field,
+							distinctFields(context, node.field),
 							node.op !== "eq" && node.op !== "ne",
 							node.value,
 							["value"],
@@ -536,20 +568,28 @@ const conditionIssues = (
 			)
 		}
 		case "In": {
+			if (!room(0)) {
+				return []
+			}
 			const exists = readIssues(context, node.field, ["field"])
+			if (exists.length > 0) {
+				return here(exists)
+			}
+			const fields = distinctFields(context, node.field)
+			if (!spendChecks(context.memo, node.values.length, fields.length)) {
+				return []
+			}
 			return here(
-				exists.length > 0
-					? exists
-					: Arr.flatMap(node.values, (operand, index) =>
-							operandIssues(context, node.field, false, operand, [
-								"values",
-								index,
-							]),
-						),
+				Arr.flatMap(node.values, (operand, index) =>
+					operandIssues(context, node.field, fields, false, operand, [
+						"values",
+						index,
+					]),
+				),
 			)
 		}
 		case "Exists":
-			return here(readIssues(context, node.field, ["field"]))
+			return room(0) ? here(readIssues(context, node.field, ["field"])) : []
 		case "Under":
 			return here(underIssues(context, node.prefix, []))
 		case "And":
@@ -582,15 +622,18 @@ const hasAction = (
 	Arr.some(actions, (action) => descriptor.actions.includes(action))
 
 /**
- * Checks one rule against a domain. It gives one issue for each problem. `at`
- * is the path of the rule, for the paths of the issues.
+ * Checks one rule against a domain. It gives one issue for each problem, up
+ * to the most issues of the binding. `at` gives the path of the rule, and it
+ * is made only for an issue that the binding keeps: a rule with very many
+ * problems deep in a tree does not make a full path for each one.
  */
 export const ruleIssues = (
 	domain: Domain.Any,
 	rule: RuleData,
-	at: ReadonlyArray<PropertyKey>,
+	at: LazyPath,
 	memo: Memo = makeMemo(),
 ): ReadonlyArray<Issue> => {
+	const here = (issues: ReadonlyArray<Issue>) => under(memo, at, issues)
 	const all = rule.resources.includes("*")
 	// Each kind is checked one time, also when the list names it again. The
 	// names come from a policy, so a native `Set` finds the copies:
@@ -623,46 +666,77 @@ export const ruleIssues = (
 	const actions = Array.from(
 		new Set(Arr.flatMap(known, (descriptor) => descriptor.actions)),
 	)
+	const fieldIssues = Arr.flatMap(rule.fields ?? [], (field, index) =>
+		here(
+			field.includes("*")
+				? patternIssues(memo, known, field, ["fields", index])
+				: fieldIssue(context, field, ["fields", index]),
+		),
+	)
+	const whenIssues =
+		rule.when === undefined
+			? []
+			: Nodes.isNode(rule.when)
+				? conditionIssues(
+						context,
+						rule.when,
+						() => [...at(), "when"],
+						new Set(),
+					)
+				: here([notWhole(["when"])])
+	// The work is known only after every check of the rule. Past the limit, a
+	// check gives no issue, so this issue must come, or the policy would load
+	// with checks left out.
+	const work = memo.work.steps > Limits.searchSteps && !memo.work.noted
+	memo.work.noted ||= work
 	return [
-		...Arr.map(
+		...Arr.flatMap(
 			Arr.filter(names, (kind) => !HashMap.has(domain.resources, kind)),
-			(kind): Issue => ({
-				path: [...at, "resources"],
-				issue: suggestIn(
-					memo,
-					`There is no resource with the kind "${kind}"`,
-					kind,
-					"~kinds",
-					() => kinds,
-				),
-			}),
+			(kind: string) =>
+				here([
+					{
+						path: ["resources"],
+						issue: suggestIn(
+							memo,
+							`There is no resource with the kind "${kind}"`,
+							kind,
+							"~kinds",
+							() => kinds,
+						),
+					},
+				]),
 		),
-		...Arr.map(
+		...Arr.flatMap(
 			Arr.filter(
 				rule.actions,
 				(action) => action !== "*" && !actions.includes(action),
 			),
-			(action): Issue => ({
-				path: [...at, "actions"],
-				issue: suggestIn(
-					memo,
-					`The action "${action}" is not an action of these resources`,
-					action,
-					`~actions\u0000${names.join(",")}`,
-					() => actions,
-				),
-			}),
-		),
-		...Arr.flatMap(rule.fields ?? [], (field, index) =>
-			field.includes("*")
-				? patternIssues(memo, known, field, [...at, "fields", index])
-				: fieldIssue(context, field, [...at, "fields", index]),
+			(action: string) =>
+				here([
+					{
+						path: ["actions"],
+						issue: suggestIn(
+							memo,
+							`The action "${action}" is not an action of these resources`,
+							action,
+							`~actions\u0000${names.join(",")}`,
+							() => actions,
+						),
+					},
+				]),
 		),
-		...(rule.when === undefined
-			? []
-			: Nodes.isNode(rule.when)
-				? conditionIssues(context, rule.when, () => [...at, "when"], new Set())
-				: [notWhole([...at, "when"])]),
+		...fieldIssues,
+		...whenIssues,
+		// The issue of the work is not one of the most issues of the binding,
+		// so a policy past the limit always says why.
+		...(work
+			? [
+					{
+						path: at(),
+						issue: `The policy takes more than ${String(Limits.searchSteps)} steps to check: its field patterns, and the fields and values of its tests on each resource. The most is ${String(Limits.searchSteps)}.`,
+					},
+				]
+			: []),
 	]
 }
 
@@ -725,7 +799,7 @@ export const treeIssues = (
 	const memo = makeMemo()
 	return Arr.flatMap(rulesOf(root, undefined, 1), (found) =>
 		Array.isArray(found)
-			? ruleIssues(domain, found[0], Place.pathOf(found[1]), memo)
+			? ruleIssues(domain, found[0], () => Place.pathOf(found[1]), memo)
 			: [found as Issue],
 	)
 }

package/src/internal/catalog.ts

@@ -418,15 +418,6 @@ const namesOf = (
  */
 const branchOf = (place: Place, count: { size: number }): Branch => {
 	const structs = Arr.filter(Arr.map(place.schemas, structOf), isStruct)
-	// The structs of classes. A value of a class is not copied into a plain
-	// object, so it keeps its getters and methods.
-	const classes = Arr.filter(
-		Arr.map(
-			Arr.filter(place.schemas, (schema) => schema._tag === "Declaration"),
-			structOf,
-		),
-		isStruct,
-	)
 	const values = Arr.filter(
 		place.schemas,
 		(schema) => !isStruct(structOf(schema)),
@@ -488,12 +479,18 @@ const branchOf = (place: Place, count: { size: number }): Branch => {
 		}
 	}
 	const structProperties = Arr.map(structs, propertiesOf)
-	const classProperties = Arr.map(classes, propertiesOf)
 	const children = Arr.map(namesOf(structs), (name) => {
 		const properties = Arr.flatMap(structProperties, (named) => {
 			const property = named.get(name)
 			return property === undefined ? [] : [property]
 		})
+		// A struct without the name may still have it as an extra field, with
+		// any value: only a decode or a `make` takes extra fields away, and a
+		// decision may get a value made by hand. A value that may be any
+		// object, as one of `Schema.Unknown` may, may have the name with any
+		// value too.
+		const top =
+			place.top || valueKinds.object || properties.length < structs.length
 		const below: Place = {
 			path: [...place.path, name],
 			schemas: Arr.flatMap(properties, (property) =>
@@ -505,15 +502,10 @@ const branchOf = (place: Place, count: { size: number }): Branch => {
 				place.missing ||
 				values.length > 0 ||
 				Arr.some(properties, (property) => SchemaAST.isOptional(property.type)),
-			// A struct without the name may still have it as an extra field,
-			// with any value: only a decode takes extra fields away. A value
-			// that may be any object, as one of `Schema.Unknown` may, may have
-			// the name with any value too.
-			top: place.top || valueKinds.object || properties.length < structs.length,
-			plain:
-				place.plain &&
-				!valueKinds.object &&
-				Arr.every(classProperties, (named) => named.has(name)),
+			top,
+			// A value that may be anything may be a list, or have a getter, so
+			// a read below it may not find plain data.
+			plain: place.plain && !top,
 		}
 		return [name, branchOf(below, count)] as const
 	})
@@ -522,6 +514,8 @@ const branchOf = (place: Place, count: { size: number }): Branch => {
 	if (signatures.length === 0) {
 		return { field, children, names, key: undefined, keyBranch: undefined }
 	}
+	const keyTop =
+		place.top || valueKinds.object || records.length < structs.length
 	const key: Key = {
 		_tag: "Key",
 		parameters: Arr.map(signatures, (signature) => signature.parameter),
@@ -534,11 +528,8 @@ const branchOf = (place: Place, count: { size: number }): Branch => {
 			),
 			// A record may not have a given key.
 			missing: true,
-			top: place.top || valueKinds.object || records.length < structs.length,
-			plain:
-				place.plain &&
-				!valueKinds.object &&
-				Arr.every(classes, (struct) => struct.indexSignatures.length > 0),
+			top: keyTop,
+			plain: place.plain && !keyTop,
 		},
 		count,
 	)

package/src/internal/nodes.ts

@@ -124,24 +124,39 @@ const checkOperands = (values: unknown): ReadonlyArray<Operand> => {
 
 interface Facts {
 	readonly size: number
+	readonly weight: number
 	readonly depth: number
 	readonly opaque: boolean
 }
 
-const leaf: Facts = { size: 1, depth: 1, opaque: false }
+const leaf: Facts = { size: 1, weight: 1, depth: 1, opaque: false }
 
-/** The facts of a node with children. It stops a node past the limits. */
-const factsOf = (children: ReadonlyArray<Node>): Facts => {
-	const size = Arr.reduce(children, 1, (total, child) => total + child.size)
-	if (size > Limits.conditionNodes) {
+/**
+ * The facts of a test with values, as `In` and `Under`. Each value counts in
+ * the weight, since a walk that reads the test reads its values too. It stops
+ * a test past the limits.
+ */
+const valuesFacts = (values: ReadonlyArray<Operand>): Facts =>
+	checkWeight({ ...leaf, weight: 1 + values.length })
+
+const checkWeight = (facts: Facts): Facts => {
+	if (facts.weight > Limits.conditionNodes) {
 		throw Limits.exceeded(
 			"A condition",
 			"conditionNodes",
-			"nodes",
-			size,
+			"nodes and values",
+			facts.weight,
 			Limits.conditionNodes,
 		)
 	}
+	return facts
+}
+
+/** The facts of a node with children. It stops a node past the limits. */
+const factsOf = (children: ReadonlyArray<Node>): Facts => {
+	const size = Arr.reduce(children, 1, (total, child) => total + child.size)
+	const weight = Arr.reduce(children, 1, (total, child) => total + child.weight)
+	checkWeight({ ...leaf, weight })
 	const depth =
 		1 + Arr.reduce(children, 0, (top, child) => Math.max(top, child.depth))
 	if (depth > Limits.conditionDepth) {
@@ -155,6 +170,7 @@ const factsOf = (children: ReadonlyArray<Node>): Facts => {
 	}
 	return {
 		size,
+		weight,
 		depth,
 		opaque: Arr.some(children, (child) => child.opaque),
 	}
@@ -183,6 +199,15 @@ abstract class Base extends Data.Class {
 		return this.#facts.size
 	}
 
+	/**
+	 * The number of nodes and of the values of their `In` and `Under` tests,
+	 * with a shared child counted for each place. A walk that reads the tests
+	 * does this much work, so the limits of the nodes count it.
+	 */
+	get weight(): number {
+		return this.#facts.weight
+	}
+
 	/** The number of levels. */
 	get depth(): number {
 		return this.#facts.depth
@@ -244,10 +269,8 @@ export class In extends Base {
 		readonly field: string
 		readonly values: ReadonlyArray<Operand>
 	}) {
-		super(
-			{ field: checkPath(props.field), values: checkOperands(props.values) },
-			leaf,
-		)
+		const values = checkOperands(props.values)
+		super({ field: checkPath(props.field), values }, valuesFacts(values))
 	}
 }
 
@@ -265,7 +288,8 @@ export class Under extends Base {
 	readonly _tag = "Under"
 	declare readonly prefix: ReadonlyArray<Operand>
 	constructor(props: { readonly prefix: ReadonlyArray<Operand> }) {
-		super({ prefix: checkOperands(props.prefix) }, leaf)
+		const prefix = checkOperands(props.prefix)
+		super({ prefix }, valuesFacts(prefix))
 	}
 }
 
@@ -333,7 +357,7 @@ export class Predicate extends Base {
 		}
 		super(
 			{ name: props.name, run: props.run },
-			{ size: 1, depth: 1, opaque: true },
+			{ size: 1, weight: 1, depth: 1, opaque: true },
 		)
 	}
 }

package/src/internal/policy-nodes.ts

@@ -130,7 +130,8 @@ export class Rules extends Base {
 				size: Arr.reduce(
 					conditions,
 					1,
-					(total, when) => total + 1 + (when?.size ?? 0),
+					// A condition counts its nodes and the values of its tests.
+					(total, when) => total + 1 + (when?.weight ?? 0),
 				),
 				depth: 1,
 				opaque: Arr.some(conditions, (when) => when?.opaque ?? false),

package/src/internal/trampoline.ts

@@ -0,0 +1,147 @@
+/**
+ * Walks that do not fill the stack.
+ *
+ * A walk is written one time, with the steps of a {@link Runner}, and a
+ * runner runs it:
+ * - {@link direct} runs each step at once, as a plain call does. It is fast,
+ *   and it is for an input with few levels.
+ * - {@link loop} puts each step into the run loop of an Effect. A step gives
+ *   the next step in place of calling it, and the loop runs one step after
+ *   the other, so the stack does not grow with the levels of the input. This
+ *   is a trampoline.
+ *
+ * {@link run} takes `direct` for an input with at most `directDepth` levels,
+ * and `loop` for a deeper one. A walk makes each call for a child through
+ * `suspend`, so the loop makes the step of the child only when it runs it.
+ */
+import * as Arr from "effect/Array"
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as Option from "effect/Option"
+
+/**
+ * A step of a walk that gives an `A`. A runner of steps knows what a step
+ * is: the value itself for `direct`, and an Effect for `loop`. The type is
+ * only in the types.
+ */
+export interface Step<A> {
+	readonly "~Step": (_: never) => A
+}
+
+/** The steps that a walk may take. */
+export interface Runner {
+	readonly succeed: <A>(value: A) => Step<A>
+	/** The step that `step` makes, when the runner runs it. */
+	readonly suspend: <A>(step: () => Step<A>) => Step<A>
+	readonly map: <A, B>(step: Step<A>, f: (value: A) => B) => Step<B>
+	readonly flatMap: <A, B>(step: Step<A>, f: (value: A) => Step<B>) => Step<B>
+	/** Runs a step for each item, in order, and gives their values. */
+	readonly forEach: <A, B>(
+		items: ReadonlyArray<A>,
+		f: (item: A, index: number) => Step<B>,
+	) => Step<ReadonlyArray<B>>
+	/** Runs a step for each item, in order, up to the first `true`. */
+	readonly some: <A>(
+		items: ReadonlyArray<A>,
+		f: (item: A) => Step<boolean>,
+	) => Step<boolean>
+	/** Runs a step for each item, in order, up to the first `false`. */
+	readonly every: <A>(
+		items: ReadonlyArray<A>,
+		f: (item: A) => Step<boolean>,
+	) => Step<boolean>
+}
+
+// A step of `direct` is its value. The casts below only change the type.
+const value = <A>(step: Step<A>): A => step as unknown as A
+const step = <A>(value: A): Step<A> => value as unknown as Step<A>
+
+/** Runs each step at once, on the stack. */
+export const direct: Runner = {
+	succeed: step,
+	suspend: (make) => make(),
+	map: (from, f) => step(f(value(from))),
+	flatMap: (from, f) => f(value(from)),
+	forEach: (items, f) =>
+		step(Arr.map(items, (item, index) => value(f(item, index)))),
+	some: (items, f) => step(Arr.some(items, (item) => value(f(item)))),
+	every: (items, f) => step(Arr.every(items, (item) => value(f(item)))),
+}
+
+// A step of `loop` is an Effect with no error and no services. A failure of a
+// walk is a thrown error, which `run` gives back as it was.
+type Loop<A> = Effect.Effect<A>
+const effect = <A>(step: Step<A>): Loop<A> => step as unknown as Loop<A>
+const fromEffect = <A>(effect: Loop<A>): Step<A> => effect as unknown as Step<A>
+
+/** Runs each step in the run loop of an Effect, so a deep walk does not fill the stack. */
+export const loop: Runner = {
+	succeed: (value) => fromEffect(Effect.succeed(value)),
+	suspend: (make) => fromEffect(Effect.suspend(() => effect(make()))),
+	map: (from, f) => fromEffect(Effect.map(effect(from), f)),
+	flatMap: (from, f) =>
+		fromEffect(Effect.flatMap(effect(from), (value) => effect(f(value)))),
+	forEach: (items, f) =>
+		fromEffect(Effect.forEach(items, (item, index) => effect(f(item, index)))),
+	some: (items, f) =>
+		fromEffect(
+			Effect.map(
+				Effect.findFirst(items, (item) => effect(f(item))),
+				Option.isSome,
+			),
+		),
+	every: (items, f) =>
+		fromEffect(
+			Effect.map(
+				Effect.findFirst(items, (item) =>
+					Effect.map(effect(f(item)), (value) => !value),
+				),
+				Option.isNone,
+			),
+		),
+}
+
+/**
+ * The most levels of an input that `run` walks with `direct`. A level takes
+ * a few calls of the walk and of the runner on the stack, so this keeps the
+ * stack far from full, and most inputs take the fast way.
+ */
+export const directDepth = 200
+
+/**
+ * Gives the runner for an input with `depth` levels. The walks of a condition
+ * or a policy tree know the depth of the input from its node. A walk of an
+ * input with an unknown depth, as a decoder, takes `loop`.
+ */
+export const runnerFor = (depth: number): Runner =>
+	depth <= directDepth ? direct : loop
+
+/**
+ * Runs a walk at once, with the runner for `depth` levels, and gives its
+ * value. An error that a step throws comes out as it was, also from `loop`.
+ */
+export const run = <A>(depth: number, walk: (runner: Runner) => Step<A>): A =>
+	runWith(runnerFor(depth), walk)
+
+/** Runs a walk at once with a runner, as {@link run} does. */
+export const runWith = <A>(
+	runner: Runner,
+	walk: (runner: Runner) => Step<A>,
+): A => {
+	if (runner === direct) {
+		return value(walk(direct))
+	}
+	return Exit.match(Effect.runSyncExit(effect(walk(loop))), {
+		onSuccess: (result) => result,
+		onFailure: (cause) => {
+			throw Cause.squash(cause)
+		},
+	})
+}
+
+/**
+ * Gives the Effect of a step of `loop`, so a walk can go on in an Effect
+ * that runs a predicate.
+ */
+export const toEffect = <A>(step: Step<A>): Effect.Effect<A> => effect(step)