@astrale-os/kernel-dsl 1.0.0-beta.15 → 1.0.0-beta.17

package/dist/v1/language/callable/resolved.d.ts

@@ -1,3 +1,4 @@
+import type { Options } from '@astrale-os/kernel-dsl/value';
 import type { DefinitionKey, FunctionRef, Key, MethodKey } from '../../addressing/index.js';
 import type { ResolvedClass } from '../class/resolved.js';
 import type { CallablePolicy } from '../policy/model/policy.js';
@@ -36,7 +37,11 @@ export interface ResolvedMethod<out Input = unknown, out Output = unknown, out S
         readonly static: Static;
         readonly abstract: Abstract;
     };
-    validateInput(input: unknown): readonly Diagnostic[];
+    /**
+     * The issues of `input` against the callable's input schema, `options` overriding the portable
+     * limits it is admitted under: those it crossed the wire under, for a call's input.
+     */
+    validateInput(input: unknown, options?: Options): readonly Diagnostic[];
     validateInputField(field: string, input: unknown): readonly Diagnostic[];
     validateOutput(output: unknown): readonly Diagnostic[];
     readonly __input?: Input;
@@ -62,7 +67,11 @@ export interface ResolvedFunction<out Input = unknown, out Output = unknown, out
     /** Present only when the callable input is a safely enumerable closed object. */
     readonly inputFields?: readonly string[];
     readonly definition: CallableDefinitionOf<FunctionDefinition, Auth, Policy>;
-    validateInput(input: unknown): readonly Diagnostic[];
+    /**
+     * The issues of `input` against the callable's input schema, `options` overriding the portable
+     * limits it is admitted under: those it crossed the wire under, for a call's input.
+     */
+    validateInput(input: unknown, options?: Options): readonly Diagnostic[];
     validateInputField(field: string, input: unknown): readonly Diagnostic[];
     validateOutput(output: unknown): readonly Diagnostic[];
     readonly __input?: Input;

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

@@ -1,6 +1,6 @@
 import type { ClassRef, DefinitionBase, PropertyKey } from '../../../addressing/index.js';
 import type { MethodRecord } from '../../callable/model/callable.js';
-import type { ClassPolicy, NodeClassPolicy } from '../../policy/model/policy.js';
+import type { EdgeClassPolicy, EdgeClassWritePolicy, NodeClassCreatePolicy, NodeClassPolicy, NodeClassWritePolicy } from '../../policy/model/policy.js';
 import type { DataFacet } from './data.js';
 import type { EdgeContract } from './edge.js';
 import type { EdgePropertyDefinition, NodePropertyDefinition, PropertyFacet } from './property.js';
@@ -10,15 +10,27 @@ export type ClassKind = 'node' | 'edge';
  * on that Domain; `'internal'`, those of its Domain only; `'final'`, none.
  */
 export type Inheritance = 'open' | 'internal' | 'final';
-/** An absent observation rule admits every caller; a delegation is still scoped by its ceiling. */
+/**
+ * An absent observation rule admits every caller; a delegation is still scoped by its ceiling. An
+ * absent write rule admits only the Domain that declares the Class.
+ */
 export interface NodeClassPolicies {
     readonly read?: NodeClassPolicy;
     readonly traverse?: NodeClassPolicy;
+    readonly create?: NodeClassCreatePolicy;
+    readonly update?: NodeClassWritePolicy;
+    readonly delete?: NodeClassWritePolicy;
 }
-/** An absent observation rule admits every caller; a delegation is still scoped by its ceiling. */
+/**
+ * An absent observation rule admits every caller; a delegation is still scoped by its ceiling. An
+ * absent write rule admits only the Domain that declares the Class.
+ */
 export interface EdgeClassPolicies {
-    readonly read?: ClassPolicy;
-    readonly traverse?: ClassPolicy;
+    readonly read?: EdgeClassPolicy;
+    readonly traverse?: EdgeClassPolicy;
+    readonly create?: EdgeClassWritePolicy;
+    readonly update?: EdgeClassWritePolicy;
+    readonly delete?: EdgeClassWritePolicy;
 }
 /**
  * The Properties one key of a Node Class names, own or inherited, which no two Nodes of the Classes

package/dist/v1/language/freeze.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Freeze `value` and every object it reaches, in place. An object already frozen is taken as frozen
+ * through, so a value built from frozen parts is frozen without walking them again.
+ */
+export declare function deepFreeze<T>(value: T): Readonly<T>;

package/dist/v1/{schema/canonical → language}/freeze.js

@@ -1,3 +1,7 @@
+/**
+ * Freeze `value` and every object it reaches, in place. An object already frozen is taken as frozen
+ * through, so a value built from frozen parts is frozen without walking them again.
+ */
 export function deepFreeze(value) {
     if (value === null || typeof value !== 'object' || Object.isFrozen(value)) {
         return value;

package/dist/v1/language/policy/analysis/typing.d.ts

@@ -2,6 +2,7 @@ import type { ClassRef, PolicyRef } from '../../../addressing/index.js';
 import type { EdgeContract } from '../../class/model/edge.js';
 import type { PolicyExpression, PolicyObjectRef } from '../model/policy.js';
 import type { CheckLeafClasses } from './checks.js';
+import { type ClassAncestry } from '../../class/inheritance.js';
 import { type PatternBranch } from './branches.js';
 export type ObjectContract = {
     readonly kind: 'default';
@@ -20,11 +21,13 @@ export type PolicyUseContract = {
 /** What Policy typing reads of the closure it types against: source or compiled admission. */
 export interface PolicyTypingScope {
     readonly normalized: ReadonlyMap<string, PolicyExpression>;
+    /** Each resolves, through `resolveClass`, to a Node Class. */
     readonly allNodeClasses: readonly ClassRef[];
+    /** The concrete Classes of `allNodeClasses`, in its order. */
     readonly concreteNodeClasses: readonly ClassRef[];
     isLocalPolicy(ref: PolicyRef): boolean;
-    /** Whether `candidate` is the `required` Class or a same-kind descendant. */
-    classExtends(candidate: ClassRef, required: ClassRef): boolean;
+    /** The Class a ref names in the closure, as satisfaction reads it. */
+    resolveClass(ref: ClassRef): ClassAncestry | undefined;
     edgeDeclaration(ref: ClassRef): EdgeContract | undefined;
     /** The contract of a Node a Policy pattern references, `undefined` when it has none. */
     referenceContract(ref: PolicyObjectRef): ObjectContract | undefined;

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

@@ -1,5 +1,6 @@
 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';
@@ -15,6 +16,7 @@ export class PolicyTyping {
     // paths; for that to merge distinct variables, the Policy expands deeper than
     // `limits.policy.patternDepth`.
     #expansions = new Map();
+    #index;
     constructor(scope) {
         this.scope = scope;
     }
@@ -27,9 +29,7 @@ export class PolicyTyping {
     }
     /** Whether the Policy accepts every concrete source and target pair the Edge Class accepts. */
     policyAcceptsEdgeClass(name, declaration) {
-        const endpoints = declaration.orientation === 'directed'
-            ? [declaration.endpoints.source, declaration.endpoints.target]
-            : declaration.endpoints;
+        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 })));
@@ -69,7 +69,12 @@ export class PolicyTyping {
         return branches !== undefined && branches.every((branch) => this.branchIsTyped(branch, use));
     }
     #concreteEndpointClasses(accepts) {
-        return this.scope.concreteNodeClasses.filter((candidate) => this.#classSatisfiesEndpoint(candidate, 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))
@@ -158,7 +163,7 @@ export class PolicyTyping {
             if (contract.kind === 'exact')
                 return this.#applyExact(candidates, contract.ref);
             if (contract.kind === 'default') {
-                return uniqueCandidates(this.scope.allNodeClasses.flatMap((ref) => this.#applyExact(candidates, ref)));
+                return this.#applyAnyNodeClass(candidates).filter((candidate) => candidate.kind !== 'exact' || this.#isNodeClass(candidate.ref));
             }
             return candidates;
         }
@@ -183,34 +188,38 @@ export class PolicyTyping {
                 if (definitionRefIndex(candidate.ref) === definitionRefIndex(exact))
                     result.push(candidate);
             }
-            else if (candidate.requirements.every((required) => this.scope.classExtends(exact, required))) {
+            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 uniqueCandidates(result);
+        return uniqueBy(result, candidateKey);
     }
     #applyAnyNodeClass(candidates) {
-        return uniqueCandidates(candidates.flatMap((candidate) => candidate.kind === 'exact'
-            ? [candidate]
-            : this.scope.allNodeClasses
-                .filter((ref) => candidate.requirements.every((required) => this.scope.classExtends(ref, required)))
-                .map((ref) => ({ kind: 'exact', ref }))));
+        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.scope.classExtends(candidate.ref, required))
+                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: uniqueClasses([...candidate.requirements, required]),
+                    requirements: uniqueBy([...candidate.requirements, required], definitionRefIndex),
                 });
             }
         }
-        return uniqueCandidates(result);
+        return uniqueBy(result, candidateKey);
     }
     #applyEndpoint(candidates, accepts) {
         const result = [];
@@ -220,18 +229,125 @@ export class PolicyTyping {
                     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: uniqueClasses([...candidate.requirements, accept]),
+                    requirements: uniqueBy([...candidate.requirements, accept], definitionRefIndex),
                 });
             }
         }
-        return uniqueCandidates(result);
+        return uniqueBy(result, candidateKey);
     }
     #classSatisfiesEndpoint(candidate, accepts) {
-        return accepts.some((accept) => this.scope.classExtends(candidate, accept));
+        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')
@@ -262,9 +378,7 @@ function variantsForEdge(use, typing) {
     const declaration = typing.scope.edgeDeclaration(edge.class);
     if (declaration === undefined)
         return [];
-    const endpoints = declaration.orientation === 'directed'
-        ? [declaration.endpoints.source, declaration.endpoints.target]
-        : declaration.endpoints;
+    const endpoints = endpointPair(declaration);
     const bounds = edge.repeat ?? { min: 1, max: 1 };
     if (!Number.isInteger(bounds.min) ||
         !Number.isInteger(bounds.max) ||
@@ -306,7 +420,13 @@ function variantsForEdge(use, typing) {
             });
         }
     }
-    return uniqueEdgeVariants(variants);
+    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];
@@ -314,26 +434,22 @@ function startEndpoint(endpoints, reversed) {
 function endEndpoint(endpoints, reversed) {
     return reversed ? endpoints[0] : endpoints[1];
 }
-function uniqueEdgeVariants(values) {
-    const result = new Map();
-    for (const value of values) {
-        const key = `${value.constraints
-            .map(([term, accepts]) => `${term}:${accepts.map(definitionRefIndex).sort().join(',')}`)
-            .join('|')}=${value.equalities.map(([left, right]) => `${left}:${right}`).join('|')}`;
-        result.set(key, value);
-    }
-    return [...result.values()];
+/** 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 uniqueCandidates(values) {
-    const result = new Map();
-    for (const value of values) {
-        const key = value.kind === 'exact'
-            ? `exact:${definitionRefIndex(value.ref)}`
-            : `open:${value.requirements.map(definitionRefIndex).sort().join('|')}`;
-        result.set(key, value);
-    }
-    return [...result.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 uniqueClasses(values) {
-    return [...new Map(values.map((value) => [definitionRefIndex(value), value])).values()];
+function classSetKey(refs) {
+    return refs.map(definitionRefIndex).sort().join(',');
 }

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

@@ -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;

package/dist/v1/language/policy/normalization/normalize.js

@@ -40,16 +40,16 @@ function normalizePatternOnce(value) {
     return normalizePatternNode(rewritten);
 }
 /**
- * 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 function normalizeClassRule(value) {
     if (!isClassRuleChecks(value))
         return value;
     const checks = unwrapSingleOperands(normalizePolicyChecks(value));
-    return 'check' in checks && checks.object.kind === 'self' ? checks.check : checks;
+    return ('check' in checks && checks.object.kind === 'self' ? checks.check : checks);
 }
 /** Replace each composition of one operand by that operand, merging what it then nests. */
 function unwrapSingleOperands(value) {

package/dist/v1/language/validation/rule.d.ts

@@ -8,19 +8,35 @@ import type { DiagnosticCode } from './diagnostic.js';
  * `warning`: a value schema, which the rule reports without refusing it.
  */
 export type ValueRuleStage = 'schema' | 'context' | 'value' | 'warning';
-/** The rule one value diagnostic code reports. */
-export interface ValueRule {
-    readonly stage: ValueRuleStage;
+/**
+ * The rule one diagnostic code reports, whatever it checks: what `schema.RULES` and `VALUE_RULES`
+ * say of every code, each with the stages of its own checks.
+ */
+export interface DiagnosticRule {
     /**
-     * The positions the rule constrains, which its diagnostics point at, relative to the value
-     * schema, the value or the Domain input it checks: JSON Pointer templates in which a `{name}`
-     * token stands for one token of the kind it names and `{/path*}` for any number of tokens.
+     * The positions the rule constrains, which its diagnostics point at: JSON Pointer templates in
+     * which a `{name}` token stands for one token of the kind it names and `{/path*}` for any number
+     * of tokens.
      */
     readonly positions: readonly [string, ...string[]];
     /** The rule, in one plain sentence. */
     readonly statement: string;
     /** The limits of `schema.limits` the rule enforces, by key, where it enforces some. */
     readonly limits?: readonly [LimitKey, ...LimitKey[]];
+    /**
+     * The conditions of the published JSON Schema of the document that state the rule, where some
+     * do: the URI fragment of each `if` or `not` subschema whose failure refuses the document with
+     * this rule's code.
+     */
+    readonly conditions?: readonly [string, ...string[]];
+}
+/**
+ * The rule one value diagnostic code reports. Its positions are relative to the value schema, the
+ * value or the Domain input it checks. A condition refuses a value schema of the document with
+ * `DV_VALUE_SCHEMA` and this rule's code as its `valueCode`.
+ */
+export interface ValueRule extends DiagnosticRule {
+    readonly stage: ValueRuleStage;
 }
 /**
  * Every value diagnostic code with the rule it reports. A code added to the language does not

package/dist/v1/language/validation/rule.js

@@ -1,8 +1,9 @@
+import { deepFreeze } from '../freeze.js';
 /**
  * Every value diagnostic code with the rule it reports. A code added to the language does not
  * compile until it is described here.
  */
-export const VALUE_RULES = frozen({
+export const VALUE_RULES = deepFreeze({
     CALLABLE_INPUT_FIELD_UNKNOWN: {
         stage: 'value',
         positions: [''],
@@ -80,12 +81,7 @@ export const VALUE_RULES = frozen({
     },
     VS_REFERENCE_RESOLUTION: {
         stage: 'context',
-        positions: [
-            '{/path*}/$ref',
-            '{/path*}/x-astrale-path/accepts/{index}',
-            '',
-            '/registry{/path*}',
-        ],
+        positions: ['{/path*}/$ref', '{/path*}/x-astrale-path/accepts/{index}', ''],
         statement: 'A $ref resolves to a location of its own value schema, x-astrale-path accepts Node Classes of the Domain or of a direct dependency, and the schema is checked with the exact dependency closure of its Domain.',
     },
     VS_REGEX_PORTABLE: {
@@ -103,6 +99,7 @@ export const VALUE_RULES = frozen({
         stage: 'schema',
         positions: ['{/path*}/x-astrale-value-kind'],
         statement: 'x-astrale-value-kind declares instant beside type string at any location, or blob as the whole schema of a Property, exactly as values.blob writes it.',
+        conditions: ['#/$defs/value-location/anyOf/1/if'],
     },
     VS_VALUE_KIND_JSON: {
         stage: 'warning',
@@ -110,11 +107,3 @@ export const VALUE_RULES = frozen({
         statement: 'A Property of value kind json is filtered by equality only, so its author is warned.',
     },
 });
-function frozen(rules) {
-    for (const rule of Object.values(rules)) {
-        Object.freeze(Object.freeze(rule).positions);
-        if (rule.limits !== undefined)
-            Object.freeze(rule.limits);
-    }
-    return Object.freeze(rules);
-}

package/dist/v1/language/value/evaluate/program.d.ts

@@ -1,3 +1,4 @@
+import type { Options } from '@astrale-os/kernel-dsl/value';
 import type { Diagnostic } from '../../validation/diagnostic.js';
 import type { ValueProgram } from '../compile/model.js';
-export declare function validateValueProgram(program: ValueProgram, input: unknown, roots?: readonly number[]): readonly Diagnostic[];
+export declare function validateValueProgram(program: ValueProgram, input: unknown, roots?: readonly number[], options?: Options): readonly Diagnostic[];

package/dist/v1/language/value/evaluate/program.js

@@ -1,8 +1,8 @@
 import { loadValueProgram } from '../compile/load.js';
 import { validateCanonicalJsonDomain } from '../profile/json.validate.js';
 import { evaluateInstance } from './evaluator.js';
-export function validateValueProgram(program, input, roots = [program.root]) {
-    const canonical = validateCanonicalJsonDomain(input, '');
+export function validateValueProgram(program, input, roots = [program.root], options) {
+    const canonical = validateCanonicalJsonDomain(input, '', options);
     if (canonical.length > 0)
         return canonical;
     return roots.flatMap((root) => {