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

package/dist/v1/schema/normalization/domain.js

@@ -2,6 +2,7 @@ import { json } from '@astrale-os/kernel-dsl/value';
 import { compareDefinitionRefs, compareUnicode } from '../../addressing/ordering.js';
 import { isBinaryInput } from '../../language/callable/model/callable.js';
 import { compareEdgeUniqueFields, compareEdgeUniqueTuples, compareNodeUniqueTuples, } from '../../language/class/unique.js';
+import { CLASS_OPERATIONS } from '../../language/policy/model/policy.js';
 import { normalizeClassRule, normalizePolicyChecks, normalizePolicyExpression, } from '../../language/policy/normalization/normalize.js';
 import { admitStateTopology } from '../../language/state/topology.js';
 import { canonicalizeValueSchema } from '../../language/value/profile/canonicalize.js';
@@ -72,7 +73,7 @@ function canonicalizeClass(value) {
             methods: mapRecord(value.methods, canonicalizeMethod),
             ...(value.data === undefined ? {} : { data: { mediaType: value.data.mediaType } }),
             ...(value.icon === undefined ? {} : { icon: value.icon }),
-            policies: canonicalizeNodePolicies(value.policies),
+            policies: canonicalizeClassPolicies(value.policies),
             ...(value.unique === undefined ? {} : { unique: canonicalizeNodeUnique(value.unique) }),
         };
     }
@@ -81,7 +82,7 @@ function canonicalizeClass(value) {
             ...base,
             orientation: 'directed',
             endpoints: canonicalizeDirectedEndpoints(value.endpoints),
-            policies: value.policies,
+            policies: canonicalizeClassPolicies(value.policies),
             constraints: value.constraints,
             ...(value.unique === undefined ? {} : { unique: canonicalizeUnique(value.unique) }),
         }
@@ -89,7 +90,7 @@ function canonicalizeClass(value) {
             ...base,
             orientation: 'undirected',
             endpoints: canonicalizeIncidentEndpoints(value.endpoints),
-            policies: value.policies,
+            policies: canonicalizeClassPolicies(value.policies),
             constraints: value.constraints,
         };
 }
@@ -106,11 +107,11 @@ function canonicalizeUnique(tuples) {
         .sort(compareEdgeUniqueTuples);
 }
 /** A rule keeps one spelling: normalized checks, or the Policy a lone `self` check names. */
-function canonicalizeNodePolicies(value) {
-    return {
-        ...(value.read === undefined ? {} : { read: normalizeClassRule(value.read) }),
-        ...(value.traverse === undefined ? {} : { traverse: normalizeClassRule(value.traverse) }),
-    };
+function canonicalizeClassPolicies(value) {
+    return Object.fromEntries(CLASS_OPERATIONS.flatMap((operation) => {
+        const policy = value[operation];
+        return policy === undefined ? [] : [[operation, normalizeClassRule(policy)]];
+    }));
 }
 function canonicalizeFunction(value) {
     return {

package/dist/v1/schema/resolution/domain.js

@@ -97,7 +97,7 @@ export function callableValidation(input, output, registry, patterns) {
     const fields = inputFieldNodes(inputProgram);
     return Object.freeze({
         ...(fields === undefined ? {} : { fields: Object.freeze(Object.keys(fields)) }),
-        validateInput: (value) => validatePreparedInstance(prepared.value, value),
+        validateInput: (value, options) => validatePreparedInstance(prepared.value, value, options),
         validateInputField(field, value) {
             const nodes = fields?.[field];
             return nodes === undefined

package/dist/v1/schema/resolution/origins.js

@@ -1,6 +1,6 @@
 import { compareDefinitionRefs, definitionRefIndex } from '../../addressing/ordering.js';
 import { isBinaryInput } from '../../language/callable/model/callable.js';
-import { isClassRuleChecks, policyVariableClass } from '../../language/policy/model/policy.js';
+import { CLASS_OPERATIONS, isClassRuleChecks, policyVariableClass, } from '../../language/policy/model/policy.js';
 import { isValueObject as isJsonObject } from '../../language/value/model/object.js';
 import { walkSchema } from '../../language/value/syntax/walk.js';
 /** Collect only semantic refs, never strings or objects embedded as JSON data. */
@@ -58,7 +58,8 @@ export function collectClassRefs(declaration, add) {
     Object.values(declaration.methods).forEach((method) => collectCallableRefs(method, add));
 }
 export function collectClassPolicyRefs(declaration, add) {
-    for (const policy of [declaration.policies.read, declaration.policies.traverse]) {
+    for (const operation of CLASS_OPERATIONS) {
+        const policy = declaration.policies[operation];
         if (isClassRuleChecks(policy))
             collectPolicyCheckRefs(policy, add);
         else if (typeof policy === 'object')

package/dist/v1/schema/rule.d.ts

@@ -1,5 +1,5 @@
+import type { DiagnosticRule } from '../language/validation/rule.js';
 import type { SchemaDiagnosticCode } from './diagnostic.js';
-import { type LimitKey } from '../language/limits.js';
 /**
  * What a rule reads to decide. `structure`: the shape of the document alone. `rule`: the whole
  * document. `context`: the document and its environment, so one document can be accepted in one
@@ -8,22 +8,16 @@ import { type LimitKey } from '../language/limits.js';
  * closure its acceptance retained.
  */
 export type SchemaRuleStage = 'structure' | 'rule' | 'context';
-/** The rule one Schema diagnostic code reports. */
-export interface SchemaRule {
+/**
+ * The rule one Schema diagnostic code reports. A final `{/path*}` of its positions stands for any
+ * further tokens; `{endpoint}` is `source`, `target`, `0` or `1`; `{count}` is `outgoing`,
+ * `incoming` or `incident`; `{operation}` is `read` or `traverse`; `{key}` is a Property key. A
+ * condition is a fragment such as `#/$defs/edge-class/if`.
+ */
+export interface SchemaRule extends DiagnosticRule {
     readonly stage: SchemaRuleStage;
-    /**
-     * 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 a final `{/path*}` for any
-     * further tokens. `{endpoint}` is `source`, `target`, `0` or `1`; `{count}` is `outgoing`,
-     * `incoming` or `incident`; `{operation}` is `read` or `traverse`; `{key}` is a Property key.
-     */
-    readonly positions: readonly [string, ...string[]];
-    /** The rule, in one plain sentence. */
-    readonly statement: string;
     /** What the feature the rule guards enforces on data or on calls, where it enforces something. */
     readonly enforces?: string;
-    /** The limits of `limits` the rule enforces, by key, where it enforces some. */
-    readonly limits?: readonly [LimitKey, ...LimitKey[]];
 }
 /**
  * Every Schema diagnostic code with the rule it reports. A code added to the DSL does not compile

package/dist/v1/schema/rule.js

@@ -1,6 +1,6 @@
 import { defaultLimits } from '@astrale-os/kernel-dsl/value';
+import { deepFreeze } from '../language/freeze.js';
 import { limits } from '../language/limits.js';
-import { deepFreeze } from './canonical/freeze.js';
 const ANY = ['{/path*}'];
 const CHECKS = [
     '/classes/{class}/policies/{operation}{/path*}',
@@ -38,7 +38,8 @@ export const RULES = deepFreeze({
     },
     DV_CALLABLE_IO: {
         stage: 'rule',
-        positions: [...at('/input/mode'), ...at('/output/mode')],
+        // A Method takes a value input only: its input has no mode.
+        positions: ['/functions/{function}/input/mode', ...at('/output/mode')],
         statement: 'A durable Function or Method takes a value input and returns a value output.',
     },
     DV_CLASS_ABSTRACT: {
@@ -185,6 +186,7 @@ export const RULES = deepFreeze({
         stage: 'structure',
         positions: ANY,
         statement: `The document is portable JSON: as text, UTF-8 that parses, within ${count(defaultLimits.maxBytes)} bytes, with no byte-order mark and no repeated member name; as a value, null, booleans, finite numbers other than negative zero, strings, arrays and plain objects, with no string or member name that holds U+0000 or a lone surrogate or exceeds ${count(defaultLimits.maxStringBytes)} bytes of UTF-8, at most ${count(defaultLimits.maxDepth)} nested arrays and objects, and at most ${count(defaultLimits.maxMembers)} members and items in all.`,
+        conditions: ['#/$defs/portable-string/not'],
     },
     DV_METHOD_ABSTRACT: {
         stage: 'rule',
@@ -247,6 +249,7 @@ export const RULES = deepFreeze({
             ...at('/output/item{/path*}'),
         ],
         statement: 'Every embedded value schema is in the value language: its diagnostic names the refusal in `valueCode`, and the schema of an automatic or State Property is not a blob.',
+        conditions: ['#/$defs/node-property-definition/allOf/0/if'],
     },
     PL_BUDGET: {
         stage: 'rule',
@@ -307,16 +310,19 @@ export const RULES = deepFreeze({
         stage: 'structure',
         positions: ['/functions/{function}/input'],
         statement: 'A Function input in binary mode is a binary input: it declares its metadata and maximumBytes.',
+        conditions: ['#/$defs/function-definition/properties/input/anyOf/1/not'],
     },
     STRUCTURE_CALLABLE_POLICY_AUTH: {
         stage: 'structure',
         positions: at('/policy'),
         statement: 'Only an authorized Function or Method declares a Policy.',
+        conditions: ['#/$defs/function-definition/if', '#/$defs/method-definition/if'],
     },
     STRUCTURE_DEPENDENCY_ALIAS: {
         stage: 'structure',
         positions: ['/dependencies/{alias}'],
         statement: 'A dependency alias is neither prototype nor constructor.',
+        conditions: ['#/$defs/dependency-alias/not'],
     },
     STRUCTURE_DOMAIN_NAME: {
         stage: 'structure',
@@ -338,6 +344,7 @@ export const RULES = deepFreeze({
         stage: 'structure',
         positions: ['/classes/{class}/properties/{property}/schema/x-astrale-value-kind'],
         statement: 'The schema of an Edge Property is not a blob: only a Node holds Blob contents.',
+        conditions: ['#/$defs/edge-property-definition/properties/schema/not'],
     },
     STRUCTURE_EDGE_ORIENTATION: {
         stage: 'structure',
@@ -348,6 +355,7 @@ export const RULES = deepFreeze({
         ],
         statement: 'A directed Edge Class has source and target endpoints and an undirected one two incident endpoints, and only a directed one declares unique tuples or is acyclic.',
         enforces: 'No Edges of an acyclic Class form a directed cycle.',
+        conditions: ['#/$defs/edge-class/if'],
     },
     STRUCTURE_FORMAT: {
         stage: 'structure',
@@ -384,6 +392,10 @@ export const RULES = deepFreeze({
         stage: 'structure',
         positions: ANY,
         statement: 'No object of the document has a member named __proto__, except the transitions of a State.',
+        conditions: [
+            '#/$defs/json-value/anyOf/5/propertyNames/not',
+            '#/$defs/value-schema/anyOf/1/propertyNames/not',
+        ],
     },
     STRUCTURE_REQUIRED: {
         stage: 'structure',

package/dist/v1/schema/validation/class.d.ts

@@ -1,10 +1,14 @@
 import type { ClassRef } from '../../addressing/index.js';
 import type { ClassDefinition } from '../../language/class/model/class.js';
+import type { ValueSchemaRegistry } from '../../language/value/reference/registry.js';
 import type { DefinitionAnalysisResult } from '../analysis/class.js';
 import type { SchemaDiagnostic } from '../diagnostic.js';
 import type { DomainResolutionContext } from '../resolution/context.js';
-/** Validate the semantic contracts owned by Class declarations. */
-export declare function validateDefinitions(environment: DomainResolutionContext, analysis: DefinitionAnalysisResult): readonly SchemaDiagnostic[];
+/**
+ * Validate the semantic contracts owned by Class declarations. `registry` is the candidate's value
+ * registry; each dependency's is built at most once, so the Classes share them.
+ */
+export declare function validateDefinitions(environment: DomainResolutionContext, analysis: DefinitionAnalysisResult, registry: ValueSchemaRegistry): readonly SchemaDiagnostic[];
 /** Whether `child` safely refines its parent Edge contract `parent`. */
 export declare function edgeContractRefines(environment: DomainResolutionContext, child: Extract<ClassDefinition, {
     readonly kind: 'edge';

package/dist/v1/schema/validation/class.js

@@ -10,24 +10,34 @@ import { isBlobValueSchema } from '../../language/value/model/blob.js';
 import { classifyOrdering } from '../../language/value/ordering.js';
 import { escapePointerToken } from '../../language/value/syntax/pointer.js';
 import { diagnostic } from '../diagnostic.js';
-import { createDomainValueSchemaRegistry, createValueSchemaRegistry, } from '../resolution/value.registry.js';
+import { createDomainValueSchemaRegistry } from '../resolution/value.registry.js';
 const formatDefinitionRef = Key.of;
-/** Validate the semantic contracts owned by Class declarations. */
-export function validateDefinitions(environment, analysis) {
+/**
+ * Validate the semantic contracts owned by Class declarations. `registry` is the candidate's value
+ * registry; each dependency's is built at most once, so the Classes share them.
+ */
+export function validateDefinitions(environment, analysis, registry) {
     const diagnostics = [...analysis.diagnostics];
     const schema = environment.candidate;
     let scope;
+    const registries = new Map([[schema.origin, registry]]);
+    const registryOf = (origin) => {
+        if (!registries.has(origin)) {
+            const dependency = environment.dependencies.get(origin);
+            registries.set(origin, dependency === undefined ? undefined : createDomainValueSchemaRegistry(dependency));
+        }
+        return registries.get(origin);
+    };
     for (const [name, declaration] of Object.entries(schema.classes)) {
         const ref = { origin: schema.origin, kind: 'class', name };
         const pointer = `/classes/${escapePointerToken(name)}`;
         if (!equalDefinitionRefs(declaration.ref, ref)) {
             diagnostics.push(diagnostic('DV_REF_RESOLVES', `${pointer}/ref`, `Class ref must be exactly ${formatDefinitionRef(ref)}.`, formatDefinitionRef(declaration.ref)));
         }
-        if (declaration.abstract &&
-            (declaration.policies.read !== undefined || declaration.policies.traverse !== undefined)) {
-            diagnostics.push(diagnostic('DV_CLASS_ABSTRACT', `${pointer}/policies`, 'Abstract Classes cannot declare observation Policies.'));
+        if (declaration.abstract && Object.keys(declaration.policies).length > 0) {
+            diagnostics.push(diagnostic('DV_CLASS_ABSTRACT', `${pointer}/policies`, 'Abstract Classes cannot declare Class Policies.'));
         }
-        validateFacet(environment, declaration, pointer, diagnostics);
+        validateFacet(registry, declaration, pointer, diagnostics);
         validateParents(environment, ref, declaration.kind, declaration.extends, diagnostics);
         if (declaration.kind === 'edge') {
             validateEdgeContract(environment, ref, declaration, pointer, diagnostics);
@@ -35,12 +45,11 @@ export function validateDefinitions(environment, analysis) {
             validateEdgeLifetimes(scope, ref, declaration, pointer, diagnostics);
             validateEdgeClassComposition(environment, ref, declaration, pointer, diagnostics);
         }
-        validateUniqueProperties(environment, analysis, ref, declaration, pointer, diagnostics);
+        validateUniqueProperties(registryOf, analysis, ref, declaration, pointer, diagnostics);
     }
     return Object.freeze(diagnostics);
 }
-function validateFacet(environment, declaration, pointer, diagnostics) {
-    const valueRegistry = createValueSchemaRegistry(environment);
+function validateFacet(valueRegistry, declaration, pointer, diagnostics) {
     for (const [name, property] of Object.entries(declaration.properties)) {
         const propertyPointer = `${pointer}/properties/${escapePointerToken(name)}`;
         // The structure refuses a blob on an Edge Property and a State Property on an Edge Class.
@@ -147,7 +156,7 @@ function validateEdgeContract(environment, owner, declaration, pointer, diagnost
  * inherit without redefinition, so the key reads one meaning on every descendant it covers. A Node
  * tuple names Properties only; an Edge tuple names them as `{ property }` beside its other fields.
  */
-function validateUniqueProperties(environment, analysis, owner, declaration, pointer, diagnostics) {
+function validateUniqueProperties(registryOf, analysis, owner, declaration, pointer, diagnostics) {
     if (declaration.kind === 'edge' && declaration.orientation !== 'directed')
         return;
     if (declaration.unique === undefined)
@@ -156,20 +165,6 @@ function validateUniqueProperties(environment, analysis, owner, declaration, poi
     if (properties === undefined)
         return;
     const code = declaration.kind === 'node' ? 'DV_NODE_UNIQUE' : 'DV_EDGE_UNIQUE';
-    const registries = new Map();
-    const registryOf = (origin) => {
-        if (!registries.has(origin)) {
-            const schema = environment.dependencies.get(origin);
-            const registry = origin === environment.candidate.origin
-                ? createValueSchemaRegistry(environment)
-                : schema === undefined
-                    ? undefined
-                    : createDomainValueSchemaRegistry(schema);
-            if (registry !== undefined)
-                registries.set(origin, registry);
-        }
-        return registries.get(origin);
-    };
     const check = (key, at) => {
         const property = properties.get(key);
         if (property === undefined) {

package/dist/v1/schema/validation/domain.js

@@ -15,7 +15,7 @@ export function validateDomainSchemaSemantics(schema, lookup) {
     const diagnostics = [
         ...context.diagnostics,
         ...validateEmbeddedValueSchemas(schema, registry),
-        ...validateDefinitions(context, analysis),
+        ...validateDefinitions(context, analysis, registry),
         ...validateContracts(schema, registry),
         ...validatePolicies(context, analysis),
         ...validateViews(context),

package/dist/v1/schema/validation/domain.json-schema.d.ts

@@ -1,5 +1,5 @@
 import { type core as zodCore } from 'zod';
-export type JsonSchemaDocument = zodCore.JSONSchema.JSONSchema;
+import { type JsonSchema } from './json.json-schema.js';
 /**
  * The JSON Schema of an authored Domain schema document, rendered from the structure the Kernel
  * enforces. Zod derives what it reads; `documentJsonSchema` states each refinement it cannot read,
@@ -7,7 +7,7 @@ export type JsonSchemaDocument = zodCore.JSONSchema.JSONSchema;
  * rendering, so that no check of the structure is dropped silently. Every value schema is in the
  * published dialect and states the profile rules JSON Schema can state; the others are named.
  */
-export declare function domainSchemaJsonSchema(): JsonSchemaDocument;
+export declare function domainSchemaJsonSchema(): JsonSchema;
 /**
  * Every refinement and custom part of the structure carries its statement in `documentJsonSchema`:
  * the keywords that state it, or its named rule. Only parts zod renders take part.

package/dist/v1/schema/validation/domain.json-schema.js

@@ -3,10 +3,14 @@ import { VALUE_RULES } from '../../language/validation/rule.js';
 import { escapePointerToken } from '../../language/value/syntax/pointer.js';
 import { RULES } from '../rule.js';
 import { domainSchemaStructure, documentJsonSchema, structureRules, } from './domain.structure.js';
-import { jsonValueJsonSchema, jsonValueRules } from './json.json-schema.js';
+import { jsonValueJsonSchema, jsonValueRules, } from './json.json-schema.js';
 import { valueSchemaJsonSchema, valueSchemaRules, } from './value.json-schema.js';
 /** The checks the published document names, each with its stage and the positions it constrains. */
-const namedRules = { ...structureRules, ...jsonValueRules, ...valueSchemaRules };
+const namedRules = {
+    ...structureRules,
+    ...jsonValueRules,
+    ...valueSchemaRules,
+};
 /**
  * The JSON Schema of an authored Domain schema document, rendered from the structure the Kernel
  * enforces. Zod derives what it reads; `documentJsonSchema` states each refinement it cannot read,
@@ -55,7 +59,7 @@ export function domainSchemaJsonSchema() {
         'node-property-definition': { ...nodeProperty, allOf: [values.nodeProperty] },
         ...json.definitions,
         ...values.definitions,
-    }).sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0)));
+    }).sort(byName));
     const document = { ...root, allOf: [json.root] };
     const positions = rulePositions({ ...document, $defs: definitions });
     return {
@@ -63,8 +67,9 @@ export function domainSchemaJsonSchema() {
         $id: 'https://schemas.astrale.ai/dsl/v1/domain-schema',
         title: 'V1 DomainSchema',
         $comment: 'Generated from the structure the Kernel enforces; value schemas are in the dialect https://schemas.astrale.ai/dsl/v1/value-schema. Each check JSON Schema cannot state is named under x-astrale-rules, with its stage and the positions it constrains.',
-        'x-astrale-rules': Object.fromEntries(Object.keys(namedRules).sort().map((name) => {
-            const { statement, ...rule } = namedRules[name];
+        'x-astrale-rules': Object.fromEntries(Object.entries(namedRules)
+            .sort(byName)
+            .map(([name, { statement, ...rule }]) => {
             const named = { ...rule, stage: stageOf(rule), statement };
             return [name, { ...named, positions: positions.get(name) ?? [] }];
         })),
@@ -168,8 +173,11 @@ function rulePositions(document) {
         const schema = value;
         const rules = schema['x-astrale-rule'];
         if (rules !== undefined) {
-            for (const rule of [rules].flat())
+            for (const rule of [rules].flat()) {
+                if (!isNamedRule(rule))
+                    throw new Error(`The marker ${String(rule)} names no rule.`);
                 note(rule, pointer);
+            }
             delete schema['x-astrale-rule'];
         }
         if (typeof schema.maxLength === 'number')
@@ -181,3 +189,9 @@ function rulePositions(document) {
     visit(document, '');
     return positions;
 }
+function isNamedRule(rule) {
+    return typeof rule === 'string' && Object.hasOwn(namedRules, rule);
+}
+function byName([left], [right]) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}