@astrale-os/kernel-dsl 0.2.0-beta.1 → 0.2.0-beta.11

package/dist/v1/schema/{policy/validation → validation/policy}/typing.js

@@ -1,12 +1,7 @@
-import { schemaRefIndex, } from '../../reference.js';
-import { branchesOf, branchProduct, capBranches, targetMode, termKey, } from './branches.js';
+import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { branchesOf, branchProduct, capBranches, targetMode, termKey, } from '../../../language/policy/analysis/branches.js';
 import { MAX_REPEAT } from './budgets.js';
 import { escapePointer } from './context.js';
-const IDENTITY_REF = {
-    origin: 'kernel.astrale.ai',
-    kind: 'interface',
-    name: 'Identity',
-};
 export class PolicyTyping {
     context;
     constructor(context) {
@@ -20,7 +15,7 @@ export class PolicyTyping {
             for (const [index, branch] of branches.entries()) {
                 const mode = targetMode(branch);
                 if (mode === undefined) {
-                    if (!('match' in this.context.environment.candidate.policies[name])) {
+                    if (!('match' in this.context.environment.candidate.policies[name].expression)) {
                         this.context.add('PL_TARGET', `/policies/${escapePointer(name)}`, `Expanded normalized branch ${index} must use object or both source and target, without mixing target modes.`);
                     }
                     continue;
@@ -49,7 +44,7 @@ export class PolicyTyping {
         return branches !== undefined && branches.every((branch) => this.#branchIsTyped(branch, use));
     }
     concreteEndpointClasses(accepts) {
-        return this.context.allNodeClasses.filter((candidate) => this.#classSatisfiesEndpoint(candidate, accepts));
+        return this.context.concreteNodeClasses.filter((candidate) => this.#classSatisfiesEndpoint(candidate, accepts));
     }
     endpointsOverlap(left, right) {
         const seed = [{ kind: 'open', requirements: [] }];
@@ -115,15 +110,6 @@ export class PolicyTyping {
         }
         for (const [root, members] of groups) {
             const endpointConstraints = constraints.get(root) ?? [];
-            const universal = members
-                .map((member) => ({ member, contract: targetContract(member, use) }))
-                .find((entry) => entry.contract?.kind === 'universal-interface');
-            if (universal !== undefined) {
-                if (!this.#universalGroupIsSatisfiable(members, endpointConstraints, universal.member, universal.contract.ref, branch)) {
-                    return false;
-                }
-                continue;
-            }
             let candidates = [{ kind: 'open', requirements: [] }];
             for (const member of members) {
                 candidates = this.#applyInitial(candidates, member, branch, use);
@@ -138,24 +124,9 @@ export class PolicyTyping {
         }
         return true;
     }
-    #universalGroupIsSatisfiable(members, endpoints, target, contract, branch) {
-        for (const member of members) {
-            if (member === target)
-                continue;
-            if (member === 'subject') {
-                if (!this.context.interfaceExtends(contract, IDENTITY_REF))
-                    return false;
-                continue;
-            }
-            const exact = this.#exactInitial(member, branch);
-            if (exact !== undefined)
-                return false;
-        }
-        return endpoints.every((accepts) => accepts.some((accept) => accept.kind === 'interface' && this.context.interfaceExtends(contract, accept)));
-    }
     #applyInitial(candidates, term, branch, use) {
         if (term === 'subject')
-            return this.#applyInterface(candidates, IDENTITY_REF);
+            return this.#applyAnyNodeClass(candidates);
         const contract = targetContract(term, use);
         if (contract !== undefined) {
             if (contract.kind === 'exact')
@@ -175,27 +146,21 @@ export class PolicyTyping {
         const result = [];
         for (const candidate of candidates) {
             if (candidate.kind === 'exact') {
-                if (schemaRefIndex(candidate.ref) === schemaRefIndex(exact))
+                if (definitionRefIndex(candidate.ref) === definitionRefIndex(exact))
                     result.push(candidate);
             }
-            else if (candidate.requirements.every((required) => this.context.classImplements(exact, required))) {
+            else if (candidate.requirements.every((required) => this.context.classExtends(exact, required))) {
                 result.push({ kind: 'exact', ref: exact });
             }
         }
         return uniqueCandidates(result);
     }
-    #applyInterface(candidates, required) {
-        return uniqueCandidates(candidates.flatMap((candidate) => {
-            if (candidate.kind === 'exact') {
-                return this.context.classImplements(candidate.ref, required) ? [candidate] : [];
-            }
-            return [
-                {
-                    kind: 'open',
-                    requirements: uniqueInterfaces([...candidate.requirements, required]),
-                },
-            ];
-        }));
+    #applyAnyNodeClass(candidates) {
+        return uniqueCandidates(candidates.flatMap((candidate) => candidate.kind === 'exact'
+            ? [candidate]
+            : this.context.allNodeClasses
+                .filter((ref) => candidate.requirements.every((required) => this.context.classExtends(ref, required)))
+                .map((ref) => ({ kind: 'exact', ref }))));
     }
     #applyEndpoint(candidates, accepts) {
         const result = [];
@@ -206,22 +171,16 @@ export class PolicyTyping {
                 continue;
             }
             for (const accept of accepts) {
-                if (accept.kind === 'interface') {
-                    result.push({
-                        kind: 'open',
-                        requirements: uniqueInterfaces([...candidate.requirements, accept]),
-                    });
-                }
-                else if (candidate.requirements.every((required) => this.context.classImplements(accept, required))) {
-                    result.push({ kind: 'exact', ref: accept });
-                }
+                result.push({
+                    kind: 'open',
+                    requirements: uniqueClasses([...candidate.requirements, accept]),
+                });
             }
         }
         return uniqueCandidates(result);
     }
     #classSatisfiesEndpoint(candidate, accepts) {
-        return accepts.some((accept) => (accept.kind === 'class' && schemaRefIndex(accept) === schemaRefIndex(candidate)) ||
-            (accept.kind === 'interface' && this.context.classImplements(candidate, accept)));
+        return accepts.some((accept) => this.context.classExtends(candidate, accept));
     }
 }
 function targetContract(term, use) {
@@ -234,7 +193,7 @@ function targetContract(term, use) {
     return undefined;
 }
 export function contractOfNodeDefinition(ref) {
-    return ref.kind === 'class' ? { kind: 'exact', ref } : { kind: 'universal-interface', ref };
+    return { kind: 'exact', ref };
 }
 function edgeAlternatives(edges, typing) {
     let result = [[]];
@@ -256,6 +215,9 @@ function variantsForEdge(use, typing) {
     const declaration = typing.context.edgeDeclaration(edge.class);
     if (declaration === undefined)
         return [];
+    const endpoints = declaration.orientation === 'directed'
+        ? [declaration.endpoints.source, declaration.endpoints.target]
+        : declaration.endpoints;
     const bounds = edge.repeat ?? { min: 1, max: 1 };
     if (!Number.isInteger(bounds.min) ||
         !Number.isInteger(bounds.max) ||
@@ -277,8 +239,8 @@ function variantsForEdge(use, typing) {
             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(declaration.endpoints, orientations[index] ?? false);
-                const outgoing = startEndpoint(declaration.endpoints, orientations[index + 1] ?? false);
+                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;
@@ -286,8 +248,8 @@ function variantsForEdge(use, typing) {
             }
             if (!transitionsValid)
                 continue;
-            const first = startEndpoint(declaration.endpoints, orientations[0] ?? false);
-            const last = endEndpoint(declaration.endpoints, orientations[length - 1] ?? false);
+            const first = startEndpoint(endpoints, orientations[0] ?? false);
+            const last = endEndpoint(endpoints, orientations[length - 1] ?? false);
             variants.push({
                 constraints: [
                     [sourceKey, first.accepts],
@@ -300,16 +262,16 @@ function variantsForEdge(use, typing) {
     return uniqueEdgeVariants(variants);
 }
 function startEndpoint(endpoints, reversed) {
-    return reversed ? endpoints.target : endpoints.source;
+    return reversed ? endpoints[1] : endpoints[0];
 }
 function endEndpoint(endpoints, reversed) {
-    return reversed ? endpoints.source : endpoints.target;
+    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(schemaRefIndex).sort().join(',')}`)
+            .map(([term, accepts]) => `${term}:${accepts.map(definitionRefIndex).sort().join(',')}`)
             .join('|')}=${value.equalities.map(([left, right]) => `${left}:${right}`).join('|')}`;
         result.set(key, value);
     }
@@ -319,14 +281,14 @@ function uniqueCandidates(values) {
     const result = new Map();
     for (const value of values) {
         const key = value.kind === 'exact'
-            ? `exact:${schemaRefIndex(value.ref)}`
-            : `open:${value.requirements.map(schemaRefIndex).sort().join('|')}`;
+            ? `exact:${definitionRefIndex(value.ref)}`
+            : `open:${value.requirements.map(definitionRefIndex).sort().join('|')}`;
         result.set(key, value);
     }
     return [...result.values()];
 }
-function uniqueInterfaces(values) {
-    return [...new Map(values.map((value) => [schemaRefIndex(value), value])).values()];
+function uniqueClasses(values) {
+    return [...new Map(values.map((value) => [definitionRefIndex(value), value])).values()];
 }
 class UnionFind {
     #parents = new Map();
@@ -354,4 +316,3 @@ class UnionFind {
             this.#parents.set(b, a);
     }
 }
-//# sourceMappingURL=typing.js.map

package/dist/v1/schema/{policy/validation → validation/policy}/uses.d.ts

@@ -3,4 +3,3 @@ import { type PolicyTyping } from './typing.js';
 export declare function validateReadUses(context: PolicyValidationContext, typing: PolicyTyping): void;
 export declare function validateTraverseUses(context: PolicyValidationContext, typing: PolicyTyping): void;
 export declare function validateCallableUses(context: PolicyValidationContext, typing: PolicyTyping): void;
-//# sourceMappingURL=uses.d.ts.map

package/dist/v1/schema/{policy/validation → validation/policy}/uses.js

@@ -1,18 +1,19 @@
-import { schemaRefIndex, formatSchemaRef, } from '../../reference.js';
-import { GRAPH_NODE_PATH_SCHEMA_ID } from '../../value/extensions/node-path/schema.js';
-import { normalizePolicyChecks } from '../normalize.js';
+import { Key } from '../../../addressing/index.js';
+import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { normalizePolicyChecks } from '../../../language/policy/normalization/normalize.js';
+import { GRAPH_NODE_PATH_SCHEMA_ID } from '../../../language/value/syntax/node-path/schema.js';
 import { MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, measureChecks } from './budgets.js';
 import { escapePointer } from './context.js';
 import { contractOfNodeDefinition } from './typing.js';
+const formatDefinitionRef = Key.of;
 const KERNEL_ORIGIN = 'kernel.astrale.ai';
 const PROJECTION_CLASS = nodeClassRef('Class');
 const PROJECTION_FUNCTION = nodeClassRef('Function');
-const PROJECTION_INTERFACE = nodeClassRef('Interface');
 const PROJECTION_POLICY = nodeClassRef('Policy');
 const PROJECTION_VIEW = nodeClassRef('View');
 export function validateReadUses(context, typing) {
     for (const [name, declaration] of Object.entries(context.environment.candidate.classes)) {
-        if (declaration.family !== 'node' || declaration.policies.read === undefined) {
+        if (declaration.kind !== 'node' || declaration.policies.read === undefined) {
             continue;
         }
         const pointer = `/classes/${escapePointer(name)}/policies/read`;
@@ -24,7 +25,7 @@ export function validateReadUses(context, typing) {
             ref: { origin: context.environment.candidate.origin, kind: 'class', name },
         };
         if (!typing.policyAccepts(ref.name, object)) {
-            context.add('PL_USE', pointer, `${formatSchemaRef(ref)} is not valid for every normalized branch of protected Class ${name}.`, formatSchemaRef(ref));
+            context.add('PL_USE', pointer, `${formatDefinitionRef(ref)} is not valid for every normalized branch of protected Class ${name}.`, formatDefinitionRef(ref));
         }
     }
 }
@@ -36,18 +37,21 @@ export function validateTraverseUses(context, typing) {
         const pointer = `/classes/${escapePointer(name)}/policies/traverse`;
         if (!context.resolvePolicy(ref, pointer))
             continue;
-        if (declaration.family === 'node') {
+        if (declaration.kind === 'node') {
             const object = {
                 kind: 'exact',
                 ref: { origin: context.environment.candidate.origin, kind: 'class', name },
             };
             if (!typing.policyAccepts(ref.name, object)) {
-                context.add('PL_USE', pointer, `${formatSchemaRef(ref)} is not valid for every normalized branch of traversed Node Class ${name}.`, formatSchemaRef(ref));
+                context.add('PL_USE', pointer, `${formatDefinitionRef(ref)} is not valid for every normalized branch of traversed Node Class ${name}.`, formatDefinitionRef(ref));
             }
             continue;
         }
-        const sources = typing.concreteEndpointClasses(declaration.endpoints.source.accepts);
-        const targets = typing.concreteEndpointClasses(declaration.endpoints.target.accepts);
+        const endpoints = declaration.orientation === 'directed'
+            ? [declaration.endpoints.source, declaration.endpoints.target]
+            : declaration.endpoints;
+        const sources = typing.concreteEndpointClasses(endpoints[0].accepts);
+        const targets = typing.concreteEndpointClasses(endpoints[1].accepts);
         let accepted = true;
         for (const source of sources) {
             for (const target of targets) {
@@ -60,7 +64,7 @@ export function validateTraverseUses(context, typing) {
                 break;
         }
         if (!accepted) {
-            context.add('PL_USE', pointer, `${formatSchemaRef(ref)} is not valid for every concrete source/target pair of traversed Edge Class ${name}.`, formatSchemaRef(ref));
+            context.add('PL_USE', pointer, `${formatDefinitionRef(ref)} is not valid for every concrete source/target pair of traversed Edge Class ${name}.`, formatDefinitionRef(ref));
         }
     }
 }
@@ -74,17 +78,8 @@ export function validateCallableUses(context, typing) {
             instanceMethod: false,
         });
     }
-    for (const [name, declaration] of Object.entries(context.environment.candidate.interfaces)) {
-        if (declaration.family !== 'node')
-            continue;
-        validateDeclaredMethods(context, typing, 'interfaces', name, declaration.methods, {
-            origin: context.environment.candidate.origin,
-            kind: 'interface',
-            name,
-        });
-    }
     for (const [name, declaration] of Object.entries(context.environment.candidate.classes)) {
-        if (declaration.family !== 'node')
+        if (declaration.kind !== 'node')
             continue;
         validateDeclaredMethods(context, typing, 'classes', name, declaration.methods, {
             origin: context.environment.candidate.origin,
@@ -94,7 +89,7 @@ export function validateCallableUses(context, typing) {
     }
 }
 function validateDeclaredMethods(context, typing, namespace, name, methods, receiver) {
-    const ownerAnalysis = context.analysis.definitions.get(schemaRefIndex(receiver));
+    const ownerAnalysis = context.analysis.definitions.get(definitionRefIndex(receiver));
     for (const [methodName, method] of Object.entries(methods)) {
         if (method.policy === undefined)
             continue;
@@ -135,7 +130,7 @@ function visitChecks(validation, typing, expression, context, pointer) {
             return;
         for (const contract of contracts) {
             if (!typing.policyAccepts(expression.check.name, contract)) {
-                validation.add('PL_USE', pointer, `${formatSchemaRef(expression.check)} is incompatible with the callable object contract.`, formatSchemaRef(expression.check));
+                validation.add('PL_USE', pointer, `${formatDefinitionRef(expression.check)} is incompatible with the callable object contract.`, formatDefinitionRef(expression.check));
                 break;
             }
         }
@@ -152,12 +147,6 @@ function referenceContracts(validation, ref, pointer) {
     if (ref.origin !== candidate.origin)
         return invalidPolicyObjectRef(validation, ref, pointer);
     switch (ref.kind) {
-        case 'interface': {
-            const resolved = validation.environment.resolve(ref);
-            return resolved?.ref.kind === ref.kind
-                ? [{ kind: 'exact', ref: PROJECTION_INTERFACE }]
-                : invalidPolicyObjectRef(validation, ref, pointer);
-        }
         case 'class': {
             const resolved = validation.environment.resolve(ref);
             return resolved?.ref.kind === ref.kind
@@ -181,21 +170,22 @@ function referenceContracts(validation, ref, pointer) {
             if (node === undefined)
                 return invalidPolicyObjectRef(validation, ref, pointer);
             const resolved = validation.environment.resolve(node.class);
-            const analyzed = validation.analysis.definitions.get(schemaRefIndex(node.class));
+            const analyzed = validation.analysis.definitions.get(definitionRefIndex(node.class));
             // Core validation owns invalid Core Class diagnostics. Avoid adding Policy noise for
             // a Node that cannot materialize in the first place.
             if (node.class.origin !== candidate.origin ||
                 resolved?.ref.kind !== 'class' ||
-                resolved.family !== 'node' ||
+                resolved.kind !== 'node' ||
                 analyzed === undefined) {
                 return undefined;
             }
             return [contractOfNodeDefinition(node.class)];
         }
     }
+    return invalidPolicyObjectRef(validation, ref, pointer);
 }
 function invalidPolicyObjectRef(validation, ref, pointer) {
-    validation.add('PL_REF', `${pointer}/ref`, `${formatSchemaRef(ref)} is not an exact local projected Policy object.`, formatSchemaRef(ref));
+    validation.add('PL_REF', `${pointer}/ref`, `${formatDefinitionRef(ref)} is not an exact local projected Policy object.`, formatDefinitionRef(ref));
     return undefined;
 }
 function selfContracts(validation, context, pointer) {
@@ -235,8 +225,8 @@ function inputContracts(validation, context, field, pointer) {
             return undefined;
         }
         const resolved = validation.environment.resolve(ref);
-        if (resolved === undefined || resolved.family !== 'node') {
-            validation.add('PL_USE', pointer, `input.${field} ref ${formatSchemaRef(ref)} does not resolve as an allowed Node Definition.`, formatSchemaRef(ref));
+        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'node') {
+            validation.add('PL_USE', pointer, `input.${field} ref ${formatDefinitionRef(ref)} does not resolve as an allowed Node Definition.`, formatDefinitionRef(ref));
             return undefined;
         }
         contracts.push(contractOfNodeDefinition(ref));
@@ -255,7 +245,7 @@ function isDefinitionRef(value) {
     const record = asRecord(value);
     return (record !== undefined &&
         typeof record.origin === 'string' &&
-        (record.kind === 'class' || record.kind === 'interface') &&
+        record.kind === 'class' &&
         typeof record.name === 'string');
 }
 function checkOperands(value) {
@@ -266,4 +256,3 @@ function checkOperands(value) {
 function nodeClassRef(name) {
     return { origin: KERNEL_ORIGIN, kind: 'class', name };
 }
-//# sourceMappingURL=uses.js.map

package/dist/v1/schema/{policy/validation → validation/policy}/validate.d.ts

@@ -1,5 +1,5 @@
-import type { DefinitionAnalysisResult } from '../../definition/analysis.js';
-import type { DomainDiagnostic } from '../../diagnostic.js';
+import type { DefinitionAnalysisResult } from '../../analysis/class.js';
+import type { SchemaDiagnostic } from '../../diagnostic.js';
 import type { DomainResolutionContext } from '../../resolution/context.js';
 /**
  * Validates the closed V1 Policy language after structural parsing.
@@ -8,5 +8,4 @@ import type { DomainResolutionContext } from '../../resolution/context.js';
  * failure. Environment and definition diagnostics are owned by their respective
  * validators and are therefore not repeated here.
  */
-export declare function validatePolicies(environment: DomainResolutionContext, analysis: DefinitionAnalysisResult): readonly DomainDiagnostic[];
-//# sourceMappingURL=validate.d.ts.map
+export declare function validatePolicies(environment: DomainResolutionContext, analysis: DefinitionAnalysisResult): readonly SchemaDiagnostic[];

package/dist/v1/schema/{policy/validation → validation/policy}/validate.js

@@ -21,4 +21,3 @@ export function validatePolicies(environment, analysis) {
     validateCallableUses(context, typing);
     return Object.freeze(context.diagnostics);
 }
-//# sourceMappingURL=validate.js.map

package/dist/v1/schema/{value/index.d.ts → validation/value-api.d.ts}

@@ -1,14 +1,13 @@
 /** The exact V1 value-schema grammar embedded in DomainSchema declarations. */
-import type { DomainDiagnostic } from '../diagnostic.js';
-import type { DomainSchema } from '../domain.ir.js';
-import type { OrderingKind } from './ordering.js';
-import type { JsonSchema } from './schema.js';
-export { VALUE_SCHEMA_DIALECT as DIALECT, VALUE_SCHEMA_VOCABULARY as VOCABULARY } from './schema.js';
-export type { JsonSchema as Schema, JsonSchemaObject as SchemaObject, PathAnnotation, PropertyObjectSchema as PropertySchema, ValueSchemaContext as Context, } from './schema.js';
-export { instant } from './instant.js';
-export type { OrderingKind } from './ordering.js';
+import type { Diagnostic } from '../../language/validation/diagnostic.js';
+import type { JsonSchema } from '../../language/value/model/schema.js';
+import type { OrderingKind } from '../../language/value/ordering.js';
+import type { DomainSchema } from '../model/schema.js';
+export { VALUE_SCHEMA_DIALECT as DIALECT, VALUE_SCHEMA_VOCABULARY as VOCABULARY, } from '../../language/value/model/schema.js';
+export type { JsonSchema as Schema, JsonSchemaObject as SchemaObject, PathAnnotation, PropertyObjectSchema as PropertySchema, ValueSchemaContext as Context, } from '../../language/value/model/schema.js';
+export { instant } from '../../language/value/model/instant.js';
+export type { OrderingKind } from '../../language/value/ordering.js';
 /** Validate one complete JSON value under the exact accepted schema that owns the contract. */
-export declare function validate(owner: DomainSchema, contract: JsonSchema, input: unknown, pointer?: string): readonly DomainDiagnostic[];
+export declare function validate(owner: DomainSchema, contract: JsonSchema, input: unknown, pointer?: string): readonly Diagnostic[];
 /** Return the one portable scalar ordering domain admitted by a property schema, if any. */
 export declare function classifyOrdering(owner: DomainSchema, contract: JsonSchema): OrderingKind | undefined;
-//# sourceMappingURL=index.d.ts.map

package/dist/v1/schema/{value/index.js → validation/value-api.js}

@@ -1,10 +1,10 @@
 /** The exact V1 value-schema grammar embedded in DomainSchema declarations. */
+import { validateJsonInstance } from '../../language/value/evaluate/validate.js';
+import { classifyOrdering as classifyOrderingWithRegistry } from '../../language/value/ordering.js';
 import { createDomainValueSchemaRegistry } from '../resolution/value.registry.js';
-import { validateJsonInstance } from './instance.validate.js';
-import { classifyOrdering as classifyOrderingWithRegistry } from './ordering.js';
 const registries = new WeakMap();
-export { VALUE_SCHEMA_DIALECT as DIALECT, VALUE_SCHEMA_VOCABULARY as VOCABULARY } from './schema.js';
-export { instant } from './instant.js';
+export { VALUE_SCHEMA_DIALECT as DIALECT, VALUE_SCHEMA_VOCABULARY as VOCABULARY, } from '../../language/value/model/schema.js';
+export { instant } from '../../language/value/model/instant.js';
 /** Validate one complete JSON value under the exact accepted schema that owns the contract. */
 export function validate(owner, contract, input, pointer = '') {
     return validateJsonInstance(contract, input, registryFor(owner), pointer);
@@ -21,4 +21,3 @@ function registryFor(owner) {
     }
     return registry;
 }
-//# sourceMappingURL=index.js.map

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

@@ -1,5 +1,4 @@
-import type { DomainDiagnostic } from '../diagnostic.js';
-import type { DomainSchemaIR } from '../domain.ir.js';
-import type { ValueSchemaRegistry } from '../value/registry.js';
-export declare function validateEmbeddedValueSchemas(schema: DomainSchemaIR, registry: ValueSchemaRegistry): readonly DomainDiagnostic[];
-//# sourceMappingURL=value.d.ts.map
+import type { ValueSchemaRegistry } from '../../language/value/reference/registry.js';
+import type { SchemaDiagnostic } from '../diagnostic.js';
+import type { DomainSchemaIR } from '../model/schema.js';
+export declare function validateEmbeddedValueSchemas(schema: DomainSchemaIR, registry: ValueSchemaRegistry): readonly SchemaDiagnostic[];

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

@@ -1,13 +1,7 @@
+import { validateValueSchema } from '../../language/value/profile/validate.js';
 import { diagnostic } from '../diagnostic.js';
-import { validateValueSchema } from '../value/profile/validate.js';
 export function validateEmbeddedValueSchemas(schema, registry) {
     const diagnostics = [];
-    for (const [name, value] of Object.entries(schema.types)) {
-        validate(value, 'named-type', `/types/${escapePointer(name)}`, registry, diagnostics);
-    }
-    for (const [name, declaration] of Object.entries(schema.interfaces)) {
-        validateDefinition(declaration, `/interfaces/${escapePointer(name)}`, registry, diagnostics);
-    }
     for (const [name, declaration] of Object.entries(schema.classes)) {
         validateDefinition(declaration, `/classes/${escapePointer(name)}`, registry, diagnostics);
     }
@@ -17,7 +11,9 @@ export function validateEmbeddedValueSchemas(schema, registry) {
     return Object.freeze(diagnostics);
 }
 function validateDefinition(declaration, pointer, registry, diagnostics) {
-    validate(declaration.properties, 'property-facet', `${pointer}/properties`, registry, diagnostics);
+    for (const [name, property] of Object.entries(declaration.properties)) {
+        validate(property.schema, 'property-facet', `${pointer}/properties/${escapePointer(name)}/schema`, registry, diagnostics);
+    }
     if ('methods' in declaration) {
         for (const [name, method] of Object.entries(declaration.methods)) {
             validateCallable(method, `${pointer}/methods/${escapePointer(name)}`, registry, diagnostics);
@@ -41,4 +37,3 @@ function validate(schema, context, pointer, registry, diagnostics) {
 function escapePointer(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }
-//# sourceMappingURL=value.js.map

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

@@ -0,0 +1,3 @@
+import type { SchemaDiagnostic } from '../diagnostic.js';
+import type { DomainResolutionContext } from '../resolution/context.js';
+export declare function validateViews(environment: DomainResolutionContext): readonly SchemaDiagnostic[];

package/dist/v1/schema/{view/validate.js → validation/view.js}

@@ -1,22 +1,29 @@
+import { Key } from '../../addressing/key.js';
 import { diagnostic } from '../diagnostic.js';
-import { formatSchemaRef } from '../reference.js';
+const formatDefinitionRef = Key.of;
 export function validateViews(environment) {
     const diagnostics = [];
     for (const [name, view] of Object.entries(environment.candidate.views)) {
         const pointer = `/views/${escapePointer(name)}`;
+        const ref = { origin: environment.candidate.origin, kind: 'view', name };
+        if (!sameRef(view.ref, ref)) {
+            diagnostics.push(diagnostic('DV_REF_RESOLVES', `${pointer}/ref`, `View ref must be exactly ${formatDefinitionRef(ref)}.`, formatDefinitionRef(view.ref)));
+        }
         if (view.target.kind === 'definition') {
             view.target.definitions.forEach((ref, index) => validateDefinitionTarget(environment, ref, `${pointer}/target/definitions/${index}`, diagnostics));
         }
     }
     return Object.freeze(diagnostics);
 }
+function sameRef(left, right) {
+    return left.origin === right.origin && left.kind === right.kind && left.name === right.name;
+}
 function validateDefinitionTarget(environment, ref, pointer, diagnostics) {
     const target = environment.resolve(ref);
-    if (target === undefined || target.family !== 'node') {
-        diagnostics.push(diagnostic('DV_VIEW_TARGET', pointer, `Definition target ${formatSchemaRef(ref)} does not resolve to a Node Definition.`, formatSchemaRef(ref)));
+    if (target === undefined || target.ref.kind !== 'class' || target.kind !== 'node') {
+        diagnostics.push(diagnostic('DV_VIEW_TARGET', pointer, `Definition target ${formatDefinitionRef(ref)} does not resolve to a Node Class.`, formatDefinitionRef(ref)));
     }
 }
 function escapePointer(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }
-//# sourceMappingURL=validate.js.map

package/dist/v1/value/full-match.d.ts

@@ -0,0 +1,2 @@
+/** Narrow public runtime owner for the portable full-string matcher. */
+export { fullMatch, type FullMatch } from '../language/value/syntax/full-match.js';

package/dist/v1/value/full-match.js

@@ -0,0 +1,2 @@
+/** Narrow public runtime owner for the portable full-string matcher. */
+export { fullMatch } from '../language/value/syntax/full-match.js';

package/dist/v1.d.ts

@@ -1,3 +1,2 @@
-/** Compatibility source facade; the explicit V1 module is owned by `./v1/index.ts`. */
+/** Source facade for the governing V1 module. */
 export * from './v1/index.js';
-//# sourceMappingURL=v1.d.ts.map

package/dist/v1.js

@@ -1,3 +1,2 @@
-/** Compatibility source facade; the explicit V1 module is owned by `./v1/index.ts`. */
+/** Source facade for the governing V1 module. */
 export * from './v1/index.js';
-//# sourceMappingURL=v1.js.map

package/dist/value/accept.d.ts

@@ -6,4 +6,3 @@ import { type Options } from './limits.js';
  * Every source property is obtained from one descriptor snapshot. Accessors are never invoked.
  */
 export declare function accept(input: unknown, options?: Options): Value;
-//# sourceMappingURL=accept.d.ts.map

package/dist/value/accept.js

@@ -130,4 +130,3 @@ function reflect(operation, pointer, message) {
 function child(pointer, token) {
     return `${pointer}/${token.replaceAll('~', '~0').replaceAll('/', '~1')}`;
 }
-//# sourceMappingURL=accept.js.map

package/dist/value/canonical.d.ts

@@ -2,4 +2,3 @@ import { type Options } from './limits.js';
 /** RFC 8785 canonical JSON for one admitted portable snapshot. */
 export declare function serialize(input: unknown, options?: Options): string;
 export declare function encode(input: unknown, options?: Options): Uint8Array;
-//# sourceMappingURL=canonical.d.ts.map

package/dist/value/canonical.js

@@ -39,4 +39,3 @@ function serializeObject(value) {
 function compareUtf16(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
-//# sourceMappingURL=canonical.js.map

package/dist/value/decode.d.ts

@@ -2,4 +2,3 @@ import type { Value } from './types.js';
 import { type Options } from './limits.js';
 /** Strictly decode one bounded JSON value. */
 export declare function decode(input: string | Uint8Array, options?: Options): Value;
-//# sourceMappingURL=decode.d.ts.map

package/dist/value/decode.js

@@ -106,4 +106,3 @@ function endContainer(state, kind, offset) {
 function failSyntax(message, offset) {
     throw new DecodeError('JSON_SYNTAX', message, offset);
 }
-//# sourceMappingURL=decode.js.map

package/dist/value/equal.d.ts

@@ -1,4 +1,3 @@
 import type { Value } from './types.js';
 /** Compare two portable Values by their canonical JSON meaning. */
 export declare function equal(left: Value, right: Value): boolean;
-//# sourceMappingURL=equal.d.ts.map

package/dist/value/equal.js

@@ -3,4 +3,3 @@ import { serialize } from './json.js';
 export function equal(left, right) {
     return left === right || serialize(left) === serialize(right);
 }
-//# sourceMappingURL=equal.js.map

package/dist/value/error.d.ts

@@ -10,4 +10,3 @@ export declare class DecodeError extends SyntaxError {
     readonly offset: number;
     constructor(code: DecodeErrorCode, message: string, offset: number, options?: ErrorOptions);
 }
-//# sourceMappingURL=error.d.ts.map

package/dist/value/error.js

@@ -19,4 +19,3 @@ export class DecodeError extends SyntaxError {
         this.offset = offset;
     }
 }
-//# sourceMappingURL=error.js.map

package/dist/value/index.d.ts

@@ -7,4 +7,3 @@ export { defaultLimits } from './limits.js';
 export type { LimitOverrides, Limits, Options } from './limits.js';
 export * as json from './json.js';
 export type { Array, Object, Primitive, Value } from './types.js';
-//# sourceMappingURL=index.d.ts.map