@astrale-os/kernel-dsl 1.0.0-beta.2 → 1.0.0-beta.20

package/dist/v1/language/policy/analysis/typing.js

@@ -0,0 +1,455 @@
+import { Key } from '../../../addressing/index.js';
+import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { classSatisfies, isGraphRoot } from '../../class/inheritance.js';
+import { limits } from '../../limits.js';
+import { branchesOf, branchProduct, capBranches, targetMode, termKey, UnionFind, } from './branches.js';
+import { admittedCheckClasses } from './checks.js';
+export class PolicyTyping {
+    scope;
+    // Expanded branches of each named Policy, cached by node identity. A Policy's expansion is reused
+    // across every composition path that reaches it (and across every use site and object contract,
+    // none of which the expansion depends on), so a shared-child composition DAG is expanded in work
+    // linear in the number of Policies instead of enumerating every path. The expansion result is
+    // independent of the reaching path up to the opaque term-namespace labels, which only ever
+    // disambiguate variables within one branch and leave targetMode and branch typing unchanged.
+    // Two occurrences of one Policy in a branch share labels only when a Policy reaches it by two
+    // paths; for that to merge distinct variables, the Policy expands deeper than
+    // `limits.policy.patternDepth`.
+    #expansions = new Map();
+    #index;
+    constructor(scope) {
+        this.scope = scope;
+    }
+    /** The normalized branches of a named Policy, `undefined` when it does not expand. */
+    expandedBranches(name, namespace) {
+        return this.#expandedBranches(name, new Set(), namespace);
+    }
+    policyAccepts(name, object) {
+        return this.#policyBranchTyping(name, object)?.every(Boolean) ?? false;
+    }
+    /** Whether the Policy accepts every concrete source and target pair the Edge Class accepts. */
+    policyAcceptsEdgeClass(name, declaration) {
+        const endpoints = endpointPair(declaration);
+        const sources = this.#concreteEndpointClasses(endpoints[0].accepts);
+        const targets = this.#concreteEndpointClasses(endpoints[1].accepts);
+        return sources.every((source) => targets.every((target) => this.#policyAcceptsEdge(name, { kind: 'exact', ref: source }, { kind: 'exact', ref: target })));
+    }
+    /**
+     * How a check of the Policy types against each contract of its object, `undefined` when the
+     * Policy does not expand or one of its branches is typed for no contract.
+     */
+    checkLeafClasses(name, contracts) {
+        const typings = new Map(contracts.map((contract) => [
+            contract.kind === 'exact' ? Key.of(contract.ref) : 'default',
+            this.#policyBranchTyping(name, contract),
+        ]));
+        const admitted = admittedCheckClasses(typings);
+        return admitted === undefined ? undefined : { accepted: [...typings.keys()], admitted };
+    }
+    endpointsOverlap(left, right) {
+        const seed = [{ kind: 'open', requirements: [] }];
+        const afterLeft = this.#applyEndpoint(seed, left);
+        return this.#applyEndpoint(afterLeft, right).length > 0;
+    }
+    branchIsTyped(branch, use) {
+        if (targetMode(branch) !== use.kind)
+            return false;
+        const alternatives = edgeAlternatives(branch.edges, this);
+        return alternatives.some((variants) => this.#constraintsAreSatisfiable(branch, variants, use));
+    }
+    /** Whether each normalized branch of the Policy is typed for an object of this contract. */
+    #policyBranchTyping(name, object) {
+        const branches = this.#expandedBranches(name, new Set(), `$use:${name}`);
+        const use = { kind: 'object', object };
+        return branches?.map((branch) => this.branchIsTyped(branch, use));
+    }
+    #policyAcceptsEdge(name, source, target) {
+        const branches = this.#expandedBranches(name, new Set(), `$edge-use:${name}`);
+        const use = { kind: 'edge', source, target };
+        return branches !== undefined && branches.every((branch) => this.branchIsTyped(branch, use));
+    }
+    #concreteEndpointClasses(accepts) {
+        const { concrete } = this.#nodeClassIndex();
+        return this.#satisfyingOneOf(accepts).filter((ref) => concrete.has(definitionRefIndex(ref)));
+    }
+    #nodeClassIndex() {
+        this.#index ??= nodeClassIndex(this.scope);
+        return this.#index;
+    }
+    #expandedBranches(name, visiting, namespace) {
+        if (visiting.has(name))
+            return undefined;
+        const cached = this.#expansions.get(name);
+        if (cached !== undefined || this.#expansions.has(name))
+            return cached;
+        const expanded = this.#expandDeclaration(name, visiting, namespace);
+        this.#expansions.set(name, expanded);
+        return expanded;
+    }
+    #expandDeclaration(name, visiting, namespace) {
+        const declaration = this.scope.normalized.get(name);
+        if (declaration === undefined)
+            return undefined;
+        if ('match' in declaration)
+            return branchesOf(declaration.match, namespace);
+        const nested = new Set(visiting);
+        nested.add(name);
+        const refs = 'allOf' in declaration ? declaration.allOf : declaration.anyOf;
+        const children = [];
+        for (const [index, ref] of refs.entries()) {
+            if (!this.scope.isLocalPolicy(ref))
+                return undefined;
+            const expanded = this.#expandedBranches(ref.name, nested, `${namespace}/${index}:${ref.name}`);
+            if (expanded === undefined)
+                return undefined;
+            children.push(expanded);
+        }
+        return 'allOf' in declaration ? branchProduct(children) : capBranches(children.flat());
+    }
+    #constraintsAreSatisfiable(branch, variants, use) {
+        const terms = new Set(use.kind === 'object' ? ['subject', 'object'] : ['subject', 'source', 'target']);
+        for (const key of branch.variables.keys())
+            terms.add(key);
+        for (const key of branch.terms.keys())
+            terms.add(key);
+        for (const edge of branch.edges) {
+            terms.add(termKey(edge.pattern.source, edge.namespace));
+            terms.add(termKey(edge.pattern.target, edge.namespace));
+        }
+        const union = new UnionFind(terms);
+        for (const [left, right] of branch.equalities)
+            union.join(left, right);
+        for (const variant of variants) {
+            for (const [left, right] of variant.equalities)
+                union.join(left, right);
+        }
+        const constraints = new Map();
+        for (const variant of variants) {
+            for (const [term, accepts] of variant.constraints) {
+                const root = union.find(term);
+                const values = constraints.get(root) ?? [];
+                values.push(accepts);
+                constraints.set(root, values);
+            }
+        }
+        const groups = new Map();
+        for (const term of terms) {
+            const root = union.find(term);
+            const members = groups.get(root) ?? [];
+            members.push(term);
+            groups.set(root, members);
+        }
+        for (const [root, members] of groups) {
+            const endpointConstraints = constraints.get(root) ?? [];
+            let candidates = [{ kind: 'open', requirements: [] }];
+            for (const member of members) {
+                candidates = this.#applyInitial(candidates, member, branch, use);
+                if (candidates.length === 0)
+                    return false;
+            }
+            for (const endpoint of endpointConstraints) {
+                candidates = this.#applyEndpoint(candidates, endpoint);
+                if (candidates.length === 0)
+                    return false;
+            }
+        }
+        return true;
+    }
+    #applyInitial(candidates, term, branch, use) {
+        if (term === 'subject')
+            return this.#applyAnyNodeClass(candidates);
+        const contract = targetContract(term, use);
+        if (contract !== undefined) {
+            if (contract.kind === 'exact')
+                return this.#applyExact(candidates, contract.ref);
+            if (contract.kind === 'default') {
+                return this.#applyAnyNodeClass(candidates).filter((candidate) => candidate.kind !== 'exact' || this.#isNodeClass(candidate.ref));
+            }
+            return candidates;
+        }
+        const referenced = branch.terms.get(term);
+        if (referenced?.kind === 'ref') {
+            const contract = this.scope.referenceContract(referenced.ref);
+            return contract?.kind === 'exact' ? this.#applyExact(candidates, contract.ref) : [];
+        }
+        const selector = branch.variables.get(term);
+        if (selector === undefined)
+            return [];
+        if (selector.kind === 'exact')
+            return this.#applyExact(candidates, selector.class);
+        if (selector.kind === 'any')
+            return candidates;
+        return this.#applyRequirement(candidates, selector.class);
+    }
+    #applyExact(candidates, exact) {
+        const result = [];
+        for (const candidate of candidates) {
+            if (candidate.kind === 'exact') {
+                if (definitionRefIndex(candidate.ref) === definitionRefIndex(exact))
+                    result.push(candidate);
+            }
+            else if (candidate.kind === 'node') {
+                if (this.#isNodeClass(exact) && this.#satisfiesLists(exact, candidate.lists)) {
+                    result.push({ kind: 'exact', ref: exact });
+                }
+            }
+            else if (candidate.requirements.every((required) => this.#classExtends(exact, required))) {
+                result.push({ kind: 'exact', ref: exact });
+            }
+        }
+        return uniqueBy(result, candidateKey);
+    }
+    #applyAnyNodeClass(candidates) {
+        return uniqueBy(candidates.flatMap((candidate) => candidate.kind === 'exact' ? [candidate] : this.#nodeCandidates(candidate)), candidateKey);
+    }
+    #applyRequirement(candidates, required) {
+        const result = [];
+        for (const candidate of candidates) {
+            if (candidate.kind === 'exact') {
+                if (this.#classExtends(candidate.ref, required))
+                    result.push(candidate);
+            }
+            else if (candidate.kind === 'node') {
+                result.push(...this.#inhabited([...candidate.lists, [required]]));
+            }
+            else {
+                result.push({
+                    kind: 'open',
+                    requirements: uniqueBy([...candidate.requirements, required], definitionRefIndex),
+                });
+            }
+        }
+        return uniqueBy(result, candidateKey);
+    }
+    #applyEndpoint(candidates, accepts) {
+        const result = [];
+        for (const candidate of candidates) {
+            if (candidate.kind === 'exact') {
+                if (this.#classSatisfiesEndpoint(candidate.ref, accepts))
+                    result.push(candidate);
+                continue;
+            }
+            if (candidate.kind === 'node') {
+                if (accepts.length > 0)
+                    result.push(...this.#inhabited([...candidate.lists, accepts]));
+                continue;
+            }
+            for (const accept of accepts) {
+                result.push({
+                    kind: 'open',
+                    requirements: uniqueBy([...candidate.requirements, accept], definitionRefIndex),
+                });
+            }
+        }
+        return uniqueBy(result, candidateKey);
+    }
+    #classSatisfiesEndpoint(candidate, accepts) {
+        return accepts.some((accept) => this.#classExtends(candidate, accept));
+    }
+    /** Whether `candidate` is the `required` Class or a same-kind descendant. */
+    #classExtends(candidate, required) {
+        const resolve = (ref) => this.scope.resolveClass(ref);
+        const actual = resolve(candidate);
+        const target = resolve(required);
+        return actual !== undefined && target !== undefined && classSatisfies(actual, target, resolve);
+    }
+    /**
+     * The Node Classes of the closure that satisfy one Class of `accepts`, in closure order: those
+     * `#classSatisfiesEndpoint` accepts, read from the index rather than tested one by one.
+     */
+    #satisfyingOneOf(accepts) {
+        const index = this.#nodeClassIndex();
+        const positions = new Set();
+        for (const accept of accepts) {
+            const required = this.scope.resolveClass(accept);
+            if (required?.kind !== 'node')
+                continue;
+            if (isGraphRoot(required))
+                return index.nodeClasses;
+            for (const position of index.satisfying.get(definitionRefIndex(required.ref)) ?? []) {
+                positions.add(position);
+            }
+        }
+        return [...positions].sort((left, right) => left - right).map((at) => index.nodeClasses[at]);
+    }
+    #satisfiesLists(ref, lists) {
+        return lists.every((accepts) => this.#classSatisfiesEndpoint(ref, accepts));
+    }
+    #isNodeClass(ref) {
+        return this.#nodeClassIndex().nodes.has(definitionRefIndex(ref));
+    }
+    /** The Node Classes an open or `node` candidate can be. */
+    #nodeCandidates(candidate) {
+        return candidate.kind === 'node'
+            ? [candidate]
+            : this.#inhabited(candidate.requirements.map((required) => [required]));
+    }
+    /**
+     * The `node` candidate of these lists when some Node Class of the closure satisfies them, so that
+     * an empty one is dropped where its expansion would have been empty. A witness is almost always a
+     * Class the lists name; only when none is does the search read the Classes that satisfy the
+     * narrowest list, every witness being one of them.
+     */
+    #inhabited(lists) {
+        const fits = (ref) => this.#isNodeClass(ref) && this.#satisfiesLists(ref, lists);
+        const inhabited = lists.some((accepts) => accepts.some(fits)) ||
+            (lists.length === 0
+                ? this.scope.allNodeClasses
+                : lists
+                    .map((accepts) => this.#satisfyingOneOf(accepts))
+                    .reduce((narrowest, next) => (next.length < narrowest.length ? next : narrowest))).some(fits);
+        return inhabited ? [{ kind: 'node', lists }] : [];
+    }
+}
+/**
+ * Index each Node Class of the closure under every Class its ancestry reaches, walked as
+ * `classSatisfies` walks it: the Class itself, then each declared parent that resolves to a Node
+ * Class. A Class then satisfies a non-root Node Class exactly when it is indexed under it.
+ * `classSatisfies` compares origin and name; every ClassRef has kind `class`, so the definition
+ * index of a ref keys it as that comparison does.
+ */
+function nodeClassIndex(scope) {
+    const nodeClasses = [];
+    const satisfying = new Map();
+    for (const ref of scope.allNodeClasses) {
+        const actual = scope.resolveClass(ref);
+        if (actual?.kind !== 'node')
+            continue;
+        const position = nodeClasses.push(ref) - 1;
+        for (const key of ancestryKeys(actual, scope)) {
+            const positions = satisfying.get(key);
+            if (positions === undefined)
+                satisfying.set(key, [position]);
+            else
+                positions.push(position);
+        }
+    }
+    return {
+        nodeClasses,
+        nodes: new Set(nodeClasses.map(definitionRefIndex)),
+        concrete: new Set(scope.concreteNodeClasses.map(definitionRefIndex)),
+        satisfying,
+    };
+}
+/** The keys of the Node Classes a Node Class's ancestry reaches, itself included. */
+function ancestryKeys(actual, scope) {
+    const seen = new Set();
+    const keys = new Set();
+    const pending = [actual];
+    for (let value = pending.pop(); value !== undefined; value = pending.pop()) {
+        if (seen.has(value))
+            continue;
+        seen.add(value);
+        keys.add(definitionRefIndex(value.ref));
+        for (const parent of value.extends) {
+            const resolved = scope.resolveClass(parent);
+            if (resolved?.kind === 'node')
+                pending.push(resolved);
+        }
+    }
+    return keys;
+}
+function targetContract(term, use) {
+    if (use.kind === 'object')
+        return term === 'object' ? use.object : undefined;
+    if (term === 'source')
+        return use.source;
+    if (term === 'target')
+        return use.target;
+    return undefined;
+}
+function edgeAlternatives(edges, typing) {
+    let result = [[]];
+    for (const edge of edges) {
+        const variants = variantsForEdge(edge, typing);
+        if (variants.length === 0)
+            return [];
+        const next = [];
+        for (const prefix of result) {
+            for (const variant of variants)
+                next.push([...prefix, variant]);
+        }
+        result = next;
+    }
+    return result;
+}
+function variantsForEdge(use, typing) {
+    const edge = use.pattern;
+    const declaration = typing.scope.edgeDeclaration(edge.class);
+    if (declaration === undefined)
+        return [];
+    const endpoints = endpointPair(declaration);
+    const bounds = edge.repeat ?? { min: 1, max: 1 };
+    if (!Number.isInteger(bounds.min) ||
+        !Number.isInteger(bounds.max) ||
+        bounds.min < 0 ||
+        bounds.max < bounds.min ||
+        bounds.max > limits.policy.repetition) {
+        return [];
+    }
+    const sourceKey = termKey(edge.source, use.namespace);
+    const targetKey = termKey(edge.target, use.namespace);
+    const variants = [];
+    for (let length = bounds.min; length <= bounds.max; length++) {
+        if (length === 0) {
+            variants.push({ constraints: [], equalities: [[sourceKey, targetKey]] });
+            continue;
+        }
+        const orientationCount = declaration.orientation === 'undirected' ? 2 ** length : 1;
+        for (let mask = 0; mask < orientationCount; mask++) {
+            const orientations = Array.from({ length }, (_, index) => declaration.orientation === 'undirected' && (mask & (1 << index)) !== 0);
+            let transitionsValid = true;
+            for (let index = 0; index + 1 < length; index++) {
+                const incoming = endEndpoint(endpoints, orientations[index] ?? false);
+                const outgoing = startEndpoint(endpoints, orientations[index + 1] ?? false);
+                if (!typing.endpointsOverlap(incoming.accepts, outgoing.accepts)) {
+                    transitionsValid = false;
+                    break;
+                }
+            }
+            if (!transitionsValid)
+                continue;
+            const first = startEndpoint(endpoints, orientations[0] ?? false);
+            const last = endEndpoint(endpoints, orientations[length - 1] ?? false);
+            variants.push({
+                constraints: [
+                    [sourceKey, first.accepts],
+                    [targetKey, last.accepts],
+                ],
+                equalities: [],
+            });
+        }
+    }
+    return uniqueBy(variants, edgeVariantKey);
+}
+/** The two endpoints of an Edge Class, a directed one's as source then target. */
+function endpointPair(declaration) {
+    return declaration.orientation === 'directed'
+        ? [declaration.endpoints.source, declaration.endpoints.target]
+        : declaration.endpoints;
+}
+function startEndpoint(endpoints, reversed) {
+    return reversed ? endpoints[1] : endpoints[0];
+}
+function endEndpoint(endpoints, reversed) {
+    return reversed ? endpoints[0] : endpoints[1];
+}
+/** The values with distinct keys, each at its key's first position and holding its last value. */
+function uniqueBy(values, key) {
+    return [...new Map(values.map((value) => [key(value), value])).values()];
+}
+function edgeVariantKey(variant) {
+    const constraints = variant.constraints.map(([term, accepts]) => `${term}:${classSetKey(accepts)}`);
+    const equalities = variant.equalities.map(([left, right]) => `${left}:${right}`);
+    return `${constraints.join('|')}=${equalities.join('|')}`;
+}
+function candidateKey(candidate) {
+    if (candidate.kind === 'exact')
+        return `exact:${definitionRefIndex(candidate.ref)}`;
+    if (candidate.kind === 'open')
+        return `open:${classSetKey(candidate.requirements)}`;
+    return `node:${candidate.lists.map(classSetKey).sort().join('|')}`;
+}
+function classSetKey(refs) {
+    return refs.map(definitionRefIndex).sort().join(',');
+}

package/dist/v1/language/policy/model/policy.d.ts

@@ -65,20 +65,20 @@ export interface PolicyEdgePattern {
 }
 export type PolicyPatternExpression = PolicyEdgePattern | PolicySameNode<PolicyPatternTerm> | {
     readonly exists: {
-        readonly nodes: readonly PolicyVariable[];
+        readonly nodes: readonly [PolicyVariable, ...PolicyVariable[]];
         readonly where: PolicyPatternExpression;
     };
 } | {
-    readonly allOf: readonly PolicyPatternExpression[];
+    readonly allOf: readonly [PolicyPatternExpression, ...PolicyPatternExpression[]];
 } | {
-    readonly anyOf: readonly PolicyPatternExpression[];
+    readonly anyOf: readonly [PolicyPatternExpression, ...PolicyPatternExpression[]];
 };
 export type PolicyExpression = {
     readonly match: PolicyPatternExpression;
 } | {
-    readonly allOf: readonly PolicyRef[];
+    readonly allOf: readonly [PolicyRef, ...PolicyRef[]];
 } | {
-    readonly anyOf: readonly PolicyRef[];
+    readonly anyOf: readonly [PolicyRef, ...PolicyRef[]];
 };
 export interface PolicyDefinition extends DefinitionBase<PolicyRef> {
     readonly expression: PolicyExpression;
@@ -90,23 +90,63 @@ export type PolicyObjectRef = ClassRef | FunctionRef | PolicyRef | ViewRef | Cor
 export declare function policyObjectKey(ref: PolicyObjectRef): string;
 export declare function policyObjectOrigin(ref: PolicyObjectRef): string;
 export declare function projectedMemberClass(ref: Exclude<PolicyObjectRef, CoreRef>): ClassRef;
+export type ClassObservation = 'read' | 'traverse';
+export type ClassWrite = 'create' | 'update' | 'delete';
+export type ClassOperation = ClassObservation | ClassWrite;
+/**
+ * Every Class slot: the observations, which admit every caller when absent, then the writes, which
+ * admit only the Domain that declares the Class when absent.
+ */
+export declare const CLASS_OPERATIONS: readonly ClassOperation[];
+export declare function isClassObservation(operation: ClassOperation): operation is ClassObservation;
 /**
  * One Class observation slot: a named Policy, or `false`, the rule no caller satisfies. Its other
  * value has no spelling there: an absent observation Policy already means `true`.
  */
 export type ClassPolicy = PolicyRef | false;
-/** What a Node Class rule may check: the observed Node, or one exact projected member. */
+/**
+ * One Class write slot: a named Policy, or `true`, the rule every Identity satisfies. Its other
+ * value has no spelling there: an absent write Policy already means the owning Domain only.
+ */
+export type ClassWritePolicy = PolicyRef | true;
+/** What a Class rule may check: the observed or written instance, or one exact projected member. */
 export type ClassRuleObject = Extract<PolicyCheckObject, {
     readonly kind: 'self' | 'ref';
 }>;
 /**
- * Policy checks deciding one Node Class observation. `self` is the observed Node; a `ref` object
- * is the same Node for every candidate. A lone check of `self` is spelled as its Policy reference.
+ * Policy checks deciding one Node Class slot. `self` is the observed or written Node; a `ref`
+ * object is the same Node for every candidate. A lone check of `self` is spelled as its Policy
+ * reference.
  */
 export type ClassRuleChecks = PolicyCheckExpression<PolicyRef, ClassRuleObject>;
+/**
+ * Policy checks deciding one Edge Class slot. `self` is the observed or written Edge, checked by a
+ * Policy whose source and target are its endpoints; a `ref` object is one exact member, the same
+ * Node for every candidate. A lone check of `self` is spelled as its Policy reference.
+ */
+export type EdgeRuleChecks = ClassRuleChecks;
+/** What a Node create rule may check: one exact projected member, since the Node is not yet. */
+export type CreateRuleObject = Extract<PolicyCheckObject, {
+    readonly kind: 'ref';
+}>;
+/** Policy checks deciding the creation of a Node: every object is a `ref` member. */
+export type CreateRuleChecks = PolicyCheckExpression<PolicyRef, CreateRuleObject>;
 /** One Node Class observation slot: a Class Policy, or Policy checks over the observed Node. */
 export type NodeClassPolicy = ClassPolicy | ClassRuleChecks;
-export declare function isClassRuleChecks(value: ClassPolicy | ClassRuleChecks | undefined): value is ClassRuleChecks;
+/** One Node Class update or delete slot: a write Policy, or Policy checks over the written Node. */
+export type NodeClassWritePolicy = ClassWritePolicy | ClassRuleChecks;
+/**
+ * The Node Class create slot: `true`, or Policy checks over members. A named Policy alone has no
+ * object there, so it has no spelling.
+ */
+export type NodeClassCreatePolicy = true | CreateRuleChecks;
+/** One Edge Class observation slot: a Class Policy, or Policy checks over the observed Edge. */
+export type EdgeClassPolicy = ClassPolicy | EdgeRuleChecks;
+/** One Edge Class write slot: a write Policy, or Policy checks over the written Edge. */
+export type EdgeClassWritePolicy = ClassWritePolicy | EdgeRuleChecks;
+/** The value of any Class slot. */
+export type ClassSlotPolicy = PolicyRef | boolean | ClassRuleChecks;
+export declare function isClassRuleChecks(value: ClassSlotPolicy | undefined): value is ClassRuleChecks;
 /**
  * Whether every way Policy checks can hold passes through a check, so that the caller decides each
  * admission. `sameNode` compares two objects and names no caller.

package/dist/v1/language/policy/model/policy.js

@@ -33,6 +33,20 @@ export function projectedMemberClass(ref) {
 function kernelClassRef(name) {
     return Object.freeze({ origin: 'kernel.astrale.ai', kind: 'class', name });
 }
+/**
+ * Every Class slot: the observations, which admit every caller when absent, then the writes, which
+ * admit only the Domain that declares the Class when absent.
+ */
+export const CLASS_OPERATIONS = Object.freeze([
+    'read',
+    'traverse',
+    'create',
+    'update',
+    'delete',
+]);
+export function isClassObservation(operation) {
+    return operation === 'read' || operation === 'traverse';
+}
 export function isClassRuleChecks(value) {
     return (typeof value === 'object' &&
         ('check' in value || 'sameNode' in value || 'allOf' in value || 'anyOf' in value));

package/dist/v1/language/policy/normalization/normalize.d.ts

@@ -1,4 +1,4 @@
-import type { NodeClassPolicy, PolicyCheckExpression, PolicyExpression, PolicyPatternExpression } from '../model/policy.js';
+import type { ClassSlotPolicy, PolicyCheckExpression, PolicyExpression, PolicyPatternExpression } from '../model/policy.js';
 export declare function normalizePolicyExpression(value: PolicyExpression): PolicyExpression;
 /**
  * The fixed point of the single pass: a Pattern the single pass reproduces is returned unchanged,
@@ -6,10 +6,10 @@ export declare function normalizePolicyExpression(value: PolicyExpression): Poli
  */
 export declare function normalizePolicyPattern(value: PolicyPatternExpression): PolicyPatternExpression;
 /**
- * The one spelling of a Node Class observation rule: normalized Policy checks without a composition
- * of one operand, or the Policy that a lone check of `self` names, which is how a Class has always
- * declared one. Callable checks keep their compositions of one operand: their revisions predate
- * this rule.
+ * The one spelling of a Class rule: normalized Policy checks without a composition of one operand,
+ * or the Policy that a lone check of `self` names, which is how a Class has always declared one.
+ * Callable checks keep their compositions of one operand: their revisions predate this rule. A
+ * create rule checks no `self`, so it keeps its checks.
  */
-export declare function normalizeClassRule(value: NodeClassPolicy): NodeClassPolicy;
+export declare function normalizeClassRule<Slot extends ClassSlotPolicy>(value: Slot): Slot;
 export declare function normalizePolicyChecks(value: PolicyCheckExpression): PolicyCheckExpression;