@nmnmcc/ability 1.0.0 → 2.0.0

package/dist/Resource.js

@@ -1,760 +1,11 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import * as Arr from "effect/Array";
-import * as Option from "effect/Option";
-import * as Schema from "effect/Schema";
-import { Class as Class$1 } from "effect/Data";
-import * as HashMap from "effect/HashMap";
-import * as HashSet from "effect/HashSet";
-import { hasProperty, isObject } from "effect/Predicate";
-import * as SchemaAST from "effect/SchemaAST";
+import { makeClass, makeStruct } from "./internal/resource.js";
 // src/Resource.ts
-/**
-* A resource is a kind of thing that a person may act on, such as a Bot or a
-* document. Each resource has a kind name, a list of actions, a Schema for its
-* data, and an optional path.
-*
-* Make a resource in one of two ways:
-* - {@link Class} makes a Schema class, in the same way as
-*   `Schema.TaggedClass`. The class is a Schema, a constructor, and a resource
-*   at the same time.
-* - {@link make} makes a resource from plain fields. Its values are plain
-*   objects with a `_tag` field.
-*
-* Every value of a resource has a `_tag` field with the kind name. The library
-* uses this field to find the resource of a value. It does not guess from the
-* constructor name.
-*
-* A path puts a resource inside a tree, such as
-* `["org", organizationId, "user", ownerUserId, "bot", id]`. A condition can
-* then ask if a value is under a part of the tree. See `Condition.under`.
-*
-* @stability stable
-* @since 0.3.0
-*/
 var Resource_exports = /* @__PURE__ */ __exportAll({
 	Class: () => Class,
-	anyDomain: () => anyDomain,
-	descriptor: () => descriptor,
-	domainOf: () => domainOf,
-	fieldPaths: () => fieldPaths,
-	hasGetter: () => hasGetter,
-	hasMatchingGetter: () => hasMatchingGetter,
-	hasMatchingPath: () => hasMatchingPath,
-	hasNoValue: () => hasNoValue,
-	hasPath: () => hasPath,
-	hasValue: () => hasValue,
-	isPlainField: () => isPlainField,
-	isResource: () => isResource,
-	kindOf: () => kindOf,
 	make: () => make
 });
 /**
-* The class of the runtime data of a resource. {@link isResource} uses it to
-* know a resource.
-*/
-var ResourceDescriptor = class extends Class$1 {};
-/** The prototypes from `prototype` up, below `Object.prototype`. */
-const prototypesFrom = (prototype) => Arr.unfold(prototype, (current) => typeof current === "object" && current !== null && current !== Object.prototype ? Option.some([current, Object.getPrototypeOf(current)]) : Option.none());
-/**
-* Gives the prototype of the class of a class node, or `undefined`. The node
-* does not keep the class: a class Schema with an annotation or a check, or
-* one inside `Schema.suspend`, is a new Schema with the same node. So the
-* walk asks the node to make a value with no check, and reads its prototype.
-*
-* This uses the `"~constructor"` annotation of Effect, which is not a public
-* API: it gives a link whose decode makes a value of the class from its
-* fields without a check. When that is not so, the walk gives `undefined`,
-* and the check of a policy says no to the getter.
-*/
-const classPrototype = (ast) => {
-	const make = ast.annotations?.["~constructor"];
-	if (typeof make !== "function") return;
-	try {
-		const made = make(ast.typeParameters);
-		const decode = hasProperty(made, "link") && hasProperty(made.link, "transformation") && hasProperty(made.link.transformation, "decode") ? made.link.transformation.decode : void 0;
-		const value = hasProperty(decode, "transform") && typeof decode.transform === "function" ? decode.transform({}) : void 0;
-		return isObject(value) ? Object.getPrototypeOf(value) : void 0;
-	} catch {
-		return;
-	}
-};
-/**
-* Tests if a path names a getter of a class Schema, such as a getter of a
-* `Schema.Class` or a `Principal.Class`, at its root or in a nested field. A
-* condition reads such a field, and the types of a condition take it, so the
-* check of a policy takes it too. It goes into the fields of a struct, the
-* values of a record, the members of a union, `Schema.suspend`, and a class
-* with an annotation or a check.
-*
-* @stability stable
-* @category predicates
-* @since 1.0.0
-*/
-const hasGetter = (schema, path) => !isTooLong(path) && Schema.isSchema(schema) && getterAt(schema.ast, path.split("."), 0, (part, name) => part === name, /* @__PURE__ */ new Map());
-/**
-* The most parts that a field path may have. The walks below call themselves
-* for each part, and a path comes from the input of a policy. So a very long
-* path, as in a recursive Schema, could fill the stack.
-*/
-const maxPathParts = 256;
-/** Tests if a field path has more than {@link maxPathParts} parts. */
-const isTooLong = (path) => path.split(".", 257).length > maxPathParts;
-/**
-* Tests if a Schema has a getter of a class at a path whose parts fit
-* `parts`, as `hasGetter` does for one path. A part fits a name when `fits`
-* says so, as a part with `*` fits many names. A part `**` stands for any
-* number of parts, also none.
-*
-* @stability stable
-* @category predicates
-* @since 1.0.0
-*/
-const hasMatchingGetter = (schema, parts, fits) => parts.length <= maxPathParts && Schema.isSchema(schema) && getterAt(schema.ast, parts, 0, fits, /* @__PURE__ */ new Map());
-/** The names of the getters of a prototype and the prototypes above it. */
-const getterNames = (prototype) => Arr.flatMap(prototypesFrom(prototype), (current) => Arr.filter(Object.getOwnPropertyNames(current), (name) => Object.getOwnPropertyDescriptor(current, name)?.get !== void 0));
-const getterAt = (ast, names, index, fits, memo) => rememberAt(memo, ast, index, false, () => {
-	const name = names[index];
-	if (name === void 0) return false;
-	const last = index === names.length - 1;
-	const next = (type, at) => getterAt(type, names, at, fits, memo);
-	if (name === "**" && !last && next(ast, index + 1)) return true;
-	switch (ast._tag) {
-		case "Union": return Arr.some(ast.types, (type) => next(type, index));
-		case "Suspend": return next(ast.thunk(), index);
-		case "Declaration": {
-			const inner = classStruct(ast);
-			if (inner === void 0) return false;
-			return last ? Arr.some(getterNames(classPrototype(ast)), (getter) => fits(name, getter)) : next(inner, index);
-		}
-		case "Objects": return !last && (Arr.some(ast.propertySignatures, (property) => typeof property.name === "string" && (name === "**" && next(property.type, index) || fits(name, property.name) && next(property.type, index + 1))) || Arr.some(ast.indexSignatures, (signature) => name === "**" ? hasSomeKey(signature.parameter) && (next(signature.type, index) || next(signature.type, index + 1)) : Arr.some([name.replaceAll("*", ""), name.replaceAll("*", "a")], (key) => fits(name, key) && keyFits(signature.parameter, key)) && next(signature.type, index + 1)));
-		default: return false;
-	}
-});
-/**
-* Tests if a record takes a key. A key of an object is a string, also a key
-* that a number Schema takes: `{ 1: "a" }` has the key `"1"`. So a key that
-* is the text of a number is tried as that number too.
-*/
-const keyFits = (parameter, key) => {
-	const is = Schema.is(Schema.make(parameter));
-	return is(key) || key !== "" && String(Number(key)) === key && is(Number(key));
-};
-/**
-* Gives the struct of a `Schema.Class`. A class is a declaration with one
-* struct as its type parameter, and Effect marks it with a `"~constructor"`
-* annotation, also through more codec steps, as in
-* `Schema.fromJsonString(User)`. Other declarations, such as
-* `Schema.OptionFromNullOr` or `Schema.ReadonlyMap`, have no such mark, and
-* the fields of their type parameter are not fields of the value.
-*/
-const classStruct = (ast) => {
-	const [inner] = ast.typeParameters;
-	return ast.annotations?.["~constructor"] !== void 0 && ast.typeParameters.length === 1 && inner?._tag === "Objects" ? inner : void 0;
-};
-/**
-* Gives the structs inside a Schema, with the `Schema.suspend` nodes that are
-* open on the way to each one. The open nodes are in a native `Set`, because
-* it must find a node by the node itself: `Equal` compares Schema nodes by
-* structure, and a recursive Schema has no end. It looks through optional keys, unions such as
-* `Schema.NullOr`, `Schema.suspend`, and `Schema.Class`. A suspend node that
-* is already open is not opened again, so a recursive Schema has an end.
-*/
-const structsOf = (ast, open) => {
-	switch (ast._tag) {
-		case "Objects": return ast.propertySignatures.length === 0 ? [] : [[ast, open]];
-		case "Union": return ast.types.flatMap((type) => structsOf(type, open));
-		case "Suspend": return open.has(ast) ? [] : structsOf(ast.thunk(), /* @__PURE__ */ new Set([...open, ast]));
-		case "Declaration": {
-			const inner = classStruct(ast);
-			return inner === void 0 ? [] : structsOf(inner, open);
-		}
-		default: return [];
-	}
-};
-/** Gives the kind of value that a field holds. See {@link FieldShape}. */
-const shapeOf = (ast, open = /* @__PURE__ */ new Set()) => {
-	switch (ast._tag) {
-		case "Objects": return ast.indexSignatures.length > 0 ? "record" : "other";
-		case "Union": {
-			const shapes = ast.types.map((type) => shapeOf(type, open));
-			return shapes.every((shape) => shape === "scalar") ? "scalar" : shapes.includes("record") ? "record" : "other";
-		}
-		case "Suspend": return open.has(ast) ? "other" : shapeOf(ast.thunk(), /* @__PURE__ */ new Set([...open, ast]));
-		default: return isScalar(ast) ? "scalar" : "other";
-	}
-};
-const isScalar = (ast) => {
-	switch (ast._tag) {
-		case "String":
-		case "Number":
-		case "Boolean":
-		case "BigInt":
-		case "Symbol":
-		case "UniqueSymbol":
-		case "Literal":
-		case "Enum":
-		case "TemplateLiteral":
-		case "Null":
-		case "Undefined": return true;
-		default: return false;
-	}
-};
-/**
-* Tests if a Schema holds, in some branch, a value that is not a struct: a
-* scalar, or a value such as a record or an array.
-*/
-const holdsValue = (ast, open) => {
-	switch (ast._tag) {
-		case "Objects": return ast.propertySignatures.length === 0 || ast.indexSignatures.length > 0;
-		case "Union": return ast.types.some((type) => holdsValue(type, open));
-		case "Suspend": return !open.has(ast) && holdsValue(ast.thunk(), /* @__PURE__ */ new Set([...open, ast]));
-		case "Declaration": return classStruct(ast) === void 0;
-		default: return true;
-	}
-};
-/**
-* Gives the path of every field of a Schema, with a dot between the names of
-* nested fields. A field of a union may come two times: one time as a field
-* that holds a value, and one time as a field that holds a struct.
-*/
-const walkFields = (ast, prefix = "", open = /* @__PURE__ */ new Set()) => Arr.flatMap(structsOf(ast, open), ([struct, inner]) => Arr.flatMap(struct.propertySignatures, (property) => {
-	const name = property.name;
-	if (typeof name !== "string") return [];
-	if (name.includes(".")) throw new Error(`A field name may not have a dot: "${name}"`);
-	if (name === "") throw new Error("A field name may not be empty");
-	const path = prefix === "" ? name : `${prefix}.${name}`;
-	const type = property.type;
-	return [...holdsValue(type, inner) ? [{
-		path,
-		leaf: true,
-		type
-	}] : [], ...structsOf(type, inner).length > 0 ? [{
-		path,
-		leaf: false,
-		type
-	}, ...walkFields(type, path, inner)] : []];
-}));
-/**
-* Gives the paths of all the fields of a Schema, with dots for nested fields.
-* A nested struct gives its own path and the paths of its fields. Arrays are
-* left out. It throws when a field name has a dot or is empty, because such a
-* name would give two fields one path, or a path with an empty part.
-*
-* @stability stable
-* @category getters
-* @since 1.0.0
-*/
-const fieldPaths = (schema) => Arr.dedupe(Arr.map(walkFields(schema.ast), (visit) => visit.path));
-/** Tests if a Schema holds only plain scalars: see {@link isPlainField}. */
-/**
-* The ids of the checks that the search knows. `domainOf` reads them, so a
-* field with only these checks has an exact domain.
-*/
-const knownChecks = HashSet.make("effect/schema/isInt", "effect/schema/isFinite");
-/**
-* Tests if each check of a Schema node is a check that the search knows. A
-* check such as `isGreaterThan(0)` stops some values, and the search does not
-* see it, so it could find a value that the Schema does not take.
-*/
-const hasOnlyKnownChecks = (checks) => Arr.every(checks ?? [], (check) => check._tag === "FilterGroup" ? hasOnlyKnownChecks(check.checks) : HashSet.has(knownChecks, check.annotations?.representation?.id));
-const isPlainScalar = (ast) => {
-	if (ast._tag === "Number" ? !hasOnlyKnownChecks(ast.checks) : (ast.checks ?? []).length > 0) return false;
-	switch (ast._tag) {
-		case "String":
-		case "Number":
-		case "Boolean":
-		case "Literal":
-		case "Null":
-		case "Undefined": return true;
-		case "Union": return ast.options?.mode !== "oneOf" && Arr.every(ast.types, isPlainScalar);
-		default: return false;
-	}
-};
-/**
-* Tests if a path names a plain scalar field of a Schema: a string, a number,
-* a boolean, a literal, `null`, or an optional field or a union of these. Its
-* only checks may be integer and finite checks: another check, such as
-* `isGreaterThan(0)`, stops values that the search does not know about. On
-* the way, each part must be a required field of a plain struct with no
-* checks, with a name that is not a name of `Object.prototype`.
-*
-* `Policy.coverage` and `Condition.satisfiable` answer `All`, `None` or
-* `Some` only when each field of the condition is such a field. Their model of
-* the values of a field is exact for these Schemas. For other Schemas, such as
-* classes, records, unions of structs or declarations, a value may have data
-* that the Schema does not show, and the answer is `Unknown`.
-*
-* @stability stable
-* @category predicates
-* @since 1.0.0
-*/
-const isPlainField = (schema, path) => !isTooLong(path) && plainAt(schema.ast, path.split("."));
-const plainAt = (ast, names) => {
-	const [name, ...rest] = names;
-	if (name === void 0 || ast._tag !== "Objects" || ast.indexSignatures.length > 0 || (ast.checks ?? []).length > 0 || name in Object.prototype) return false;
-	const property = ast.propertySignatures.find((signature) => signature.name === name);
-	if (property === void 0) return false;
-	return rest.length === 0 ? isPlainScalar(property.type) : !SchemaAST.isOptional(property.type) && plainAt(property.type, rest);
-};
-/**
-* Tests if a path names a field of a Schema that holds a value with no named
-* fields: a scalar, or a value such as a record or an array. It goes into
-* records by their keys, and into recursive Schemas as far as the path goes.
-* So it finds paths that {@link fieldPaths} does not list.
-*
-* @stability stable
-* @category predicates
-* @since 1.0.0
-*/
-const hasPath = (schema, path) => !isTooLong(path) && resolves(schema.ast, path.split("."), 0, /* @__PURE__ */ new Map());
-/**
-* Gives the answer for a node at a place from the memo, or works it out and
-* keeps it. While the work runs, the memo holds `pending`, so a walk that
-* comes back to the node at the same place, with no step on the path, gets
-* `pending` and stops.
-*/
-const rememberAt = (memo, ast, index, pending, work) => {
-	const places = memo.get(ast) ?? /* @__PURE__ */ new Map();
-	memo.set(ast, places);
-	if (places.has(index)) return places.get(index);
-	places.set(index, pending);
-	const result = work();
-	places.set(index, result);
-	return result;
-};
-const resolves = (ast, names, index, memo) => rememberAt(memo, ast, index, false, () => {
-	if (index === names.length) return index > 0 && holdsValue(ast, /* @__PURE__ */ new Set());
-	const name = names[index];
-	switch (ast._tag) {
-		case "Objects": {
-			const property = ast.propertySignatures.find((signature) => signature.name === name);
-			if (property !== void 0) return resolves(property.type, names, index + 1, memo);
-			return ast.indexSignatures.some((signature) => keyFits(signature.parameter, name) && resolves(signature.type, names, index + 1, memo));
-		}
-		case "Union": return ast.types.some((type) => resolves(type, names, index, memo));
-		case "Suspend": return resolves(ast.thunk(), names, index, memo);
-		case "Declaration": {
-			const inner = classStruct(ast);
-			return inner !== void 0 && resolves(inner, names, index, memo);
-		}
-		default: return false;
-	}
-});
-/**
-* Tests if a Schema has a field whose path fits a pattern. `parts` are the
-* parts of the pattern, split at the dots. A part `**` stands for any number
-* of parts, also none. Another part fits a name when `fits` says so, as a
-* part with `*` fits many names. For a record, the walk asks if the key
-* Schema takes a key that fits the part. For a template literal key Schema,
-* with parts that are literals and strings, the answer is exact. For another key Schema, the walk tries sample keys, so it may miss a
-* key, and then the answer is `false`.
-*
-* @stability stable
-* @category predicates
-* @since 1.0.0
-*/
-const hasMatchingPath = (schema, parts, fits) => parts.length <= maxPathParts && matchesFrom(schema.ast, parts, 0, false, fits, /* @__PURE__ */ new Map());
-const matchesFrom = (ast, parts, index, stepped, fits, memo) => rememberAt(memo, ast, index * 2 + (stepped ? 1 : 0), false, () => {
-	const next = (type, at, step) => matchesFrom(type, parts, at, step, fits, memo);
-	switch (ast._tag) {
-		case "Union": return Arr.some(ast.types, (type) => next(type, index, stepped));
-		case "Suspend": return next(ast.thunk(), index, stepped);
-		case "Declaration": {
-			const inner = classStruct(ast);
-			if (inner !== void 0) return next(inner, index, stepped);
-			break;
-		}
-	}
-	if (index === parts.length) return stepped && holdsValue(ast, /* @__PURE__ */ new Set());
-	const part = parts[index];
-	if (part === "**" && next(ast, index + 1, stepped)) return true;
-	if (ast._tag !== "Objects") return false;
-	const fromPart = [part.replaceAll("*", ""), part.replaceAll("*", "a")];
-	return Arr.some(ast.propertySignatures, (property) => typeof property.name === "string" && (part === "**" ? next(property.type, index, true) : fits(part, property.name) && next(property.type, index + 1, true))) || Arr.some(ast.indexSignatures, (signature) => part === "**" ? hasSomeKey(signature.parameter) && next(signature.type, index, true) : (globMeetsKeys(part, signature.parameter) ?? Arr.some(Arr.dedupe([...fromPart, ...sampleKeys(signature.parameter)]), (key) => keyFits(signature.parameter, key) && fits(part, key))) && next(signature.type, index + 1, true));
-});
-/**
-* Tests if a key Schema takes some key: the exact search for a template
-* literal, or a sample key.
-*/
-const hasSomeKey = (parameter) => globMeetsKeys("*", parameter) ?? Arr.some(Arr.dedupe([
-	"",
-	"a",
-	...sampleKeys(parameter)
-]), (key) => keyFits(parameter, key));
-/** The longest key pattern that the exact search of keys takes. */
-const maxExactKeyLength = 256;
-const charsOf = (text) => Arr.map(Array.from(text), (char) => ({
-	_tag: "Char",
-	char
-}));
-/**
-* Gives the token lists of a template literal, one for each choice of its
-* unions of literals, or `undefined` when the lists can not be exact: a part
-* that this walk does not know, such as a number, a part with checks, or
-* more than 64 lists.
-*/
-const templateTokens = (ast) => {
-	const partTokens = (part) => {
-		if ((part.checks ?? []).length > 0) return;
-		switch (part._tag) {
-			case "Literal": {
-				const text = String(part.literal);
-				return /[\uD800-\uDFFF]/.test(text) ? void 0 : [charsOf(text)];
-			}
-			case "String": return [[{ _tag: "Any" }]];
-			case "Number": return;
-			case "Union": {
-				if (part.options?.mode === "oneOf") return;
-				const choices = Arr.map(part.types, partTokens);
-				return Arr.every(choices, (choice) => choice !== void 0) ? Arr.flatten(choices) : void 0;
-			}
-			default: return;
-		}
-	};
-	return Arr.reduce(ast.parts, [[]], (lists, part) => {
-		const choices = partTokens(part);
-		if (lists === void 0 || choices === void 0) return;
-		const all = Arr.flatMap(lists, (list) => Arr.map(choices, (choice) => [...list, ...choice]));
-		return all.length > 64 || Arr.some(all, (list) => list.length > maxExactKeyLength) ? void 0 : all;
-	});
-};
-/**
-* Tests if a key pattern and a list of template tokens share a key. It walks
-* the pairs of places in the two lists, with a few characters that stand for
-* all others, so the answer is exact for these tokens.
-*/
-const tokensMeet = (glob, template) => {
-	const key = (t, g) => t * (glob.length + 1) + g;
-	const closeOf = (t, g) => [
-		[t, g],
-		...template[t]?._tag === "Any" ? closeOf(t + 1, g) : [],
-		...glob[g]?._tag === "Star" ? closeOf(t, g + 1) : []
-	];
-	const alphabet = Arr.dedupe([
-		"a",
-		"0",
-		...Arr.flatMap(glob, (token) => token._tag === "Char" ? [token.char] : []),
-		...Arr.flatMap(template, (token) => token._tag === "Char" ? [token.char] : [])
-	]);
-	const stepTemplate = (t, char) => {
-		const token = template[t];
-		return token === void 0 ? [] : token._tag === "Any" ? [t] : token.char === char ? [t + 1] : [];
-	};
-	const stepGlob = (g, char) => {
-		const token = glob[g];
-		return token === void 0 ? [] : token._tag === "Char" ? token.char === char ? [g + 1] : [] : char === "." ? [] : [g];
-	};
-	const search = (frontier, seen) => {
-		const fresh = Array.from(HashMap.values(HashMap.fromIterable(Arr.map(Arr.filter(Arr.flatMap(frontier, ([t, g]) => closeOf(t, g)), ([t, g]) => !HashSet.has(seen, key(t, g))), (pair) => [key(pair[0], pair[1]), pair]))));
-		if (fresh.length === 0) return false;
-		if (Arr.some(fresh, ([t, g]) => t === template.length && g === glob.length)) return true;
-		const next = HashSet.union(seen, HashSet.fromIterable(Arr.map(fresh, ([t, g]) => key(t, g))));
-		return search(Arr.flatMap(fresh, ([t, g]) => Arr.flatMap(alphabet, (char) => Arr.flatMap(stepTemplate(t, char), (t2) => Arr.map(stepGlob(g, char), (g2) => [t2, g2])))), next);
-	};
-	return search([[0, 0]], HashSet.empty());
-};
-/**
-* Tests if a key pattern fits a key of a template literal key Schema, or
-* `undefined` when the search is not exact for the Schema. The search calls
-* itself one time for each character of a key, so a very long part gives
-* `undefined` too.
-*/
-const globMeetsKeys = (part, ast) => {
-	if (ast._tag !== "TemplateLiteral" || (ast.checks ?? []).length > 0 || part.length > maxExactKeyLength) return;
-	const lists = templateTokens(ast);
-	if (lists === void 0) return;
-	const glob = Arr.map(part.match(/\*+|[^*]/gu) ?? [], (token) => token.startsWith("*") ? { _tag: "Star" } : {
-		_tag: "Char",
-		char: token
-	});
-	return Arr.some(lists, (list) => tokensMeet(glob, list));
-};
-/**
-* A few keys that a key Schema of a record takes: each part of a template
-* literal gives its literal, or a short text for a string or a number. These
-* are samples. A key that is not a sample may fit too, so a "no" from a test
-* with them is only "not found".
-*/
-const sampleKeys = (ast) => {
-	switch (ast._tag) {
-		case "String": return ["", "a"];
-		case "Number": return ["0", "1"];
-		case "Literal": return [String(ast.literal)];
-		case "Union": return Arr.flatMap(ast.types, sampleKeys);
-		case "TemplateLiteral": return Arr.reduce(ast.parts, [""], (keys, part) => Arr.take(Arr.flatMap(keys, (key) => Arr.map(Arr.take(sampleKeys(part), 2), (end) => key + end)), 64));
-		default: return [];
-	}
-};
-/**
-* Tests if a Schema surely has a value: each required field, at each depth,
-* has a type that has values, with no checks other than integer and finite
-* checks on numbers. A check such as a minimum length may stop every value,
-* and the library can not see that, so such a Schema gives `false`. So does a
-* required field that holds the struct itself again.
-*
-* @stability stable
-* @category predicates
-* @since 1.0.0
-*/
-const hasValue = (schema) => isSurelyInhabited(schema.ast, /* @__PURE__ */ new Set());
-const isSurelyInhabited = (ast, open) => {
-	if (ast._tag === "Number" ? !hasOnlyKnownChecks(ast.checks) : (ast.checks ?? []).length > 0) return false;
-	switch (ast._tag) {
-		case "Never": return false;
-		case "Objects": return (ast.propertySignatures.length === 0 || ast.indexSignatures.length === 0) && Arr.every(ast.propertySignatures, (property) => SchemaAST.isOptional(property.type) || isSurelyInhabited(property.type, open));
-		case "Union": return ast.options?.mode !== "oneOf" && Arr.some(ast.types, (type) => isSurelyInhabited(type, open));
-		case "Suspend": return !open.has(ast) && isSurelyInhabited(ast.thunk(), /* @__PURE__ */ new Set([...open, ast]));
-		case "Arrays": return Arr.every([...Arr.filter(ast.elements, (element) => !SchemaAST.isOptional(element)), ...ast.rest.slice(1)], (element) => isSurelyInhabited(element, open));
-		case "Declaration": {
-			const inner = classStruct(ast);
-			if (inner !== void 0) return isSurelyInhabited(inner, open);
-			const id = declarationId(ast);
-			if (HashSet.has(wrapperDeclarations, id)) return Arr.some(ast.typeParameters, (type) => isSurelyInhabited(type, open));
-			return HashSet.has(inhabitedDeclarations, id);
-		}
-		case "Enum": return ast.enums.length > 0;
-		case "TemplateLiteral": return Arr.every(ast.parts, (part) => isSurelyInhabited(part, open));
-		case "String":
-		case "Number":
-		case "Boolean":
-		case "BigInt":
-		case "Symbol":
-		case "UniqueSymbol":
-		case "Literal":
-		case "Null":
-		case "Undefined":
-		case "Void":
-		case "Unknown":
-		case "Any":
-		case "ObjectKeyword": return true;
-		default: return false;
-	}
-};
-/** Declarations of Effect that hold a value of a type parameter. */
-const wrapperDeclarations = HashSet.make("effect/schema/Redacted", "effect/schema/Result");
-/** Declarations of Effect that have a value for any type parameters. */
-const inhabitedDeclarations = HashSet.make("effect/schema/Date", "effect/schema/URL", "effect/schema/Uint8Array", "effect/schema/Duration", "effect/schema/DateTimeUtc", "effect/schema/BigDecimal", "effect/schema/Cause", "effect/schema/Chunk", "effect/schema/HashMap", "effect/schema/HashSet", "effect/schema/ReadonlyMap", "effect/schema/ReadonlySet", "effect/schema/Option", "effect/schema/File", "effect/schema/FormData", "effect/schema/RegExp", "effect/schema/Json", "effect/schema/ByteSize", "effect/schema/DateTimeZoned", "effect/schema/Error", "effect/schema/Exit", "effect/schema/CauseReason", "effect/schema/Graph", "effect/schema/SemVer", "effect/schema/SemVerRange", "effect/schema/TimeZone", "effect/schema/TimeZoneNamed", "effect/schema/TimeZoneOffset", "effect/schema/URLSearchParams");
-/**
-* Tests if a Schema has no value at all: a required field of it, at some
-* depth, has no value, as `Schema.Never` has none. A required field that
-* holds the struct itself again, with no way to stop, has no finite value
-* either. Other checks, such as a minimum and a maximum that do not meet, are
-* not seen, so a "no" does not prove that the Schema has a value.
-*
-* @stability stable
-* @category predicates
-* @since 1.0.0
-*/
-const hasNoValue = (schema) => isEmptyType(schema.ast, /* @__PURE__ */ new Set());
-const isEmptyType = (ast, open) => {
-	switch (ast._tag) {
-		case "Never": return true;
-		case "Objects": return Arr.some(ast.propertySignatures, (property) => !SchemaAST.isOptional(property.type) && isEmptyType(property.type, open));
-		case "Union": return Arr.every(ast.types, (type) => isEmptyType(type, open));
-		case "Suspend": return open.has(ast) || isEmptyType(ast.thunk(), /* @__PURE__ */ new Set([...open, ast]));
-		case "Declaration": {
-			const inner = classStruct(ast);
-			return inner !== void 0 && isEmptyType(inner, open);
-		}
-		default: return false;
-	}
-};
-const numberOrder = [
-	"none",
-	"integer",
-	"finite",
-	"any"
-];
-const emptyDomain = {
-	null: false,
-	object: false,
-	boolean: false,
-	string: false,
-	number: "none",
-	literals: []
-};
-const nullDomain = {
-	...emptyDomain,
-	null: true
-};
-const objectDomain = {
-	...emptyDomain,
-	object: true
-};
-/**
-* The domain of a field with no Schema: any value.
-*
-* @stability stable
-* @category constants
-* @since 1.0.0
-*/
-const anyDomain = {
-	null: true,
-	object: true,
-	boolean: true,
-	string: true,
-	number: "any",
-	literals: []
-};
-const joinDomains = (domains) => domains.reduce((left, right) => ({
-	null: left.null || right.null,
-	object: left.object || right.object,
-	boolean: left.boolean || right.boolean,
-	string: left.string || right.string,
-	number: numberOrder.indexOf(left.number) >= numberOrder.indexOf(right.number) ? left.number : right.number,
-	literals: [...left.literals, ...right.literals]
-}), emptyDomain);
-const hasCheck = (checks, id) => checks.some((check) => check.annotations?.representation?.id === id || check._tag === "FilterGroup" && hasCheck(check.checks, id));
-/**
-* The ids of the declarations of Effect that hold only values with parts.
-* Effect puts the id in the `representation` annotation. A declaration that
-* is not in this list may hold a scalar, as `Schema.Json` may.
-*/
-const objectDeclarations = HashSet.make("effect/schema/Date", "effect/schema/URL", "effect/schema/Uint8Array", "effect/schema/Duration", "effect/schema/DateTimeUtc", "effect/schema/BigDecimal", "effect/schema/Redacted", "effect/schema/Cause", "effect/schema/Chunk", "effect/schema/HashMap", "effect/schema/HashSet", "effect/schema/ReadonlyMap", "effect/schema/ReadonlySet", "effect/schema/Option", "effect/schema/Result", "effect/schema/File", "effect/schema/FormData", "effect/schema/RegExp");
-const declarationId = (ast) => {
-	const representation = ast.annotations?.["representation"];
-	return hasProperty(representation, "id") && typeof representation.id === "string" ? representation.id : void 0;
-};
-/** The domain of the values of a Schema node. */
-const domainOfType = (ast, open) => {
-	switch (ast._tag) {
-		case "Null":
-		case "Undefined": return nullDomain;
-		case "Never": return emptyDomain;
-		case "Void":
-		case "Unknown":
-		case "Any": return anyDomain;
-		case "String":
-		case "TemplateLiteral": return {
-			...emptyDomain,
-			string: true
-		};
-		case "Number": {
-			const checks = ast.checks ?? [];
-			return {
-				...emptyDomain,
-				number: hasCheck(checks, "effect/schema/isInt") ? "integer" : hasCheck(checks, "effect/schema/isFinite") ? "finite" : "any"
-			};
-		}
-		case "Boolean": return {
-			...emptyDomain,
-			boolean: true
-		};
-		case "Literal": return typeof ast.literal === "bigint" ? objectDomain : {
-			...emptyDomain,
-			literals: [ast.literal]
-		};
-		case "Enum": return {
-			...emptyDomain,
-			literals: ast.enums.map(([, value]) => value)
-		};
-		case "Union": return joinDomains(ast.types.map((type) => domainOfType(type, open)));
-		case "Suspend": return open.has(ast) ? anyDomain : domainOfType(ast.thunk(), /* @__PURE__ */ new Set([...open, ast]));
-		case "Objects": return ast.propertySignatures.length === 0 && ast.indexSignatures.length === 0 ? anyDomain : objectDomain;
-		case "Declaration": return classStruct(ast) !== void 0 || HashSet.has(objectDeclarations, declarationId(ast)) ? objectDomain : anyDomain;
-		default: return objectDomain;
-	}
-};
-const domainAt = (ast, names, index, memo) => rememberAt(memo, ast, index, anyDomain, () => {
-	if (index === names.length) return domainOfType(ast, /* @__PURE__ */ new Set());
-	const name = names[index];
-	switch (ast._tag) {
-		case "Objects": {
-			const property = ast.propertySignatures.find((signature) => signature.name === name);
-			if (property !== void 0) {
-				const inner = domainAt(property.type, names, index + 1, memo);
-				return SchemaAST.isOptional(property.type) || name in Object.prototype ? joinDomains([nullDomain, inner]) : inner;
-			}
-			return anyDomain;
-		}
-		case "Union": return joinDomains(ast.types.map((type) => domainAt(type, names, index, memo)));
-		case "Suspend": return domainAt(ast.thunk(), names, index, memo);
-		case "Declaration": {
-			const inner = classStruct(ast);
-			return inner === void 0 ? anyDomain : domainAt(inner, names, index, memo);
-		}
-		case "Arrays":
-		case "ObjectKeyword":
-		case "Unknown":
-		case "Any": return anyDomain;
-		default: return nullDomain;
-	}
-});
-/**
-* Gives the domain of a field of a Schema, by its path with dots. A path that
-* the Schema does not name gives `null`, as a condition reads such a field.
-*
-* @stability stable
-* @category getters
-* @since 1.0.0
-*/
-const domainOf = (schema, path) => isTooLong(path) ? anyDomain : domainAt(schema.ast, path.split("."), 0, /* @__PURE__ */ new Map());
-/**
-* Checks the names of the top fields of a resource at once, when it is made.
-* The names of nested fields are checked when the descriptor is made.
-*/
-const checkFields = (kind, options) => {
-	if (Object.hasOwn(options.fields, "_tag")) throw new Error(`The resource "${kind}" may not have a field "_tag"`);
-	Arr.map(Object.keys(options.fields), (name) => {
-		if (name.includes(".")) throw new Error(`A field name may not have a dot: "${name}"`);
-		if (name === "") throw new Error("A field name may not be empty");
-	});
-};
-/**
-* Gives a value that is made on first use, and then kept. The descriptor of a
-* resource reads its Schema, and a recursive Schema refers to the resource
-* class, so it can not be read while the class is made. The cell belongs to
-* one resource.
-*/
-const lazy = (make) => {
-	const cell = {};
-	return () => {
-		if (!("value" in cell)) cell.value = make();
-		return cell.value;
-	};
-};
-/**
-* Checks each part of the path of a resource: a string, or a reference to a
-* top-level field of the resource. A reference to another field would read
-* nothing, and a rule on the path could then match a value by mistake.
-*/
-const checkPath = (kind, fields, path) => Arr.map(Array.from(path), (segment) => {
-	if (typeof segment === "string") return segment;
-	if (hasProperty(segment, "_tag") && segment._tag === "Field" && hasProperty(segment, "field") && typeof segment.field === "string" && Object.hasOwn(fields, segment.field)) return {
-		_tag: "Field",
-		field: segment.field
-	};
-	throw new globalThis.Error(`A part of the path of "${kind}" is not a string or a field of the resource`);
-});
-/**
-* Copies the options of a resource. The descriptor is made later, when it is
-* first read, so a change to the objects of the caller before then must not
-* change it: the Schema of the values and the descriptor must agree.
-*/
-const snapshot = (options) => ({
-	...options,
-	actions: [...options.actions],
-	fields: { ...options.fields }
-});
-const makeDescriptor = (kind, options) => {
-	const refs = Object.fromEntries(Arr.map(Object.keys(options.fields), (key) => [key, {
-		_tag: "Field",
-		field: key
-	}]));
-	const visits = walkFields(Schema.Struct(options.fields).ast);
-	const leaves = Arr.filter(visits, (visit) => visit.leaf);
-	const structs = HashSet.fromIterable(Arr.map(Arr.filter(visits, (visit) => !visit.leaf), (visit) => visit.path));
-	const open = Arr.filter(leaves, (visit) => shapeOf(visit.type) !== "scalar" || HashSet.has(structs, visit.path));
-	return new ResourceDescriptor({
-		kind,
-		actions: [...options.actions],
-		path: options.path === void 0 ? void 0 : checkPath(kind, options.fields, options.path(refs)),
-		fieldPaths: Arr.dedupe(Arr.map(leaves, (visit) => visit.path)),
-		openPaths: Arr.dedupe(Arr.map(open, (visit) => visit.path)),
-		schema: Schema.TaggedStruct(kind, options.fields)
-	});
-};
-/**
 * Makes a resource as a Schema class. Use it in the same way as
 * `Schema.TaggedClass`.
 *
@@ -763,35 +14,23 @@ const makeDescriptor = (kind, options) => {
 * import { Schema } from "effect"
 * import { Resource } from "@nmnmcc/ability"
 *
-* class Bot extends Resource.Class<Bot>()("Bot", {
+* class Document extends Resource.Class<Document>()("Document", {
 *   actions: ["read", "update"],
 *   fields: {
 *     id: Schema.String,
-*     ownerUserId: Schema.NullOr(Schema.String),
+*     teamId: Schema.NullOr(Schema.String),
 *   },
-*   path: (f) => ["user", f.ownerUserId, "bot", f.id],
+*   path: (f) => ["team", f.teamId, "doc", f.id],
 * }) {}
 *
-* const bot = new Bot({ id: "b1", ownerUserId: "u1" })
+* const document = new Document({ id: "d1", teamId: "t1" })
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 0.3.0
 */
-const Class = ((identifier) => (kind, input) => {
-	const options = snapshot(input);
-	checkFields(kind, options);
-	const Base = Schema.TaggedClass(identifier)(kind, options.fields);
-	const descriptor = lazy(() => makeDescriptor(kind, options));
-	return class extends Base {
-		static get descriptor() {
-			return descriptor();
-		}
-		static kind = kind;
-		static actions = [...options.actions];
-	};
-});
+const Class = makeClass;
 /**
 * Makes a resource from plain fields. Its values are plain objects with a
 * `_tag` field.
@@ -800,45 +39,7 @@ const Class = ((identifier) => (kind, input) => {
 * @category constructors
 * @since 0.3.0
 */
-const make = ((kind, input) => {
-	const options = snapshot(input);
-	checkFields(kind, options);
-	const schema = Schema.TaggedStruct(kind, options.fields);
-	const descriptor = lazy(() => makeDescriptor(kind, options));
-	return {
-		get descriptor() {
-			return descriptor();
-		},
-		kind,
-		actions: [...options.actions],
-		schema,
-		make: (input) => schema.make(input)
-	};
-});
-/**
-* Tests if a value is a resource.
-*
-* @stability stable
-* @category guards
-* @since 0.3.0
-*/
-const isResource = (u) => hasProperty(u, "descriptor") && u.descriptor instanceof ResourceDescriptor;
-/**
-* Gets the runtime data of a resource.
-*
-* @stability stable
-* @category getters
-* @since 0.3.0
-*/
-const descriptor = (resource) => resource.descriptor;
-/**
-* Gives the kind name of a resource value, from its `_tag` field.
-*
-* @stability stable
-* @category getters
-* @since 1.0.0
-*/
-const kindOf = (value) => hasProperty(value, "_tag") && typeof value._tag === "string" ? value._tag : void 0;
-export { Class, Resource_exports, anyDomain, descriptor, domainOf, fieldPaths, hasGetter, hasMatchingGetter, hasMatchingPath, hasNoValue, hasPath, hasValue, isPlainField, isResource, kindOf, make };
+const make = makeStruct;
+export { Class, Resource_exports, make };
 
 //# sourceMappingURL=Resource.js.map