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

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,28 +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[]];
-    /**
-     * 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, `#/$defs/edge-class/if`, whose failure
-     * refuses a document with this rule's code.
-     */
-    readonly conditions?: readonly [string, ...string[]];
 }
 /**
  * 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*}',

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

@@ -34,9 +34,8 @@ export function validateDefinitions(environment, analysis, registry) {
         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(registry, declaration, pointer, diagnostics);
         validateParents(environment, ref, declaration.kind, declaration.extends, diagnostics);

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;
+}