@astrale-os/kernel-dsl 0.2.0-beta.3 → 0.2.0-beta.31

package/dist/v1/{schema → language}/value/regexp/compile.d.ts

@@ -1,4 +1,3 @@
-import type { Pattern } from '../../compiled/model.js';
+import type { Pattern } from '../compile/model.js';
 /** Compile one admitted I-Regexp AST to portable Thompson-NFA data. */
 export declare function compilePattern(source: string): Pattern;
-//# sourceMappingURL=compile.d.ts.map

package/dist/v1/{schema → language}/value/regexp/compile.js

@@ -38,10 +38,16 @@ class Builder {
         }
         if (piece.maximum === undefined)
             return this.concat(output, this.star(piece.atom));
+        if (piece.maximum === piece.minimum)
+            return output;
+        const end = this.state();
         for (let index = piece.minimum; index < piece.maximum; index++) {
-            output = this.concat(output, this.optional(piece.atom));
+            // A shorter repetition exits the whole suffix, rather than skipping arbitrary copies.
+            this.epsilon(output.end, end);
+            output = this.concat(output, this.atom(piece.atom));
         }
-        return output;
+        this.epsilon(output.end, end);
+        return { start: output.start, end };
     }
     atom(atom) {
         if (atom.kind === 'expression')
@@ -51,15 +57,6 @@ class Builder {
         this.states[start].transitions.push({ to: end, ranges: atom.ranges });
         return { start, end };
     }
-    optional(atom) {
-        const start = this.state();
-        const end = this.state();
-        const child = this.atom(atom);
-        this.epsilon(start, end);
-        this.epsilon(start, child.start);
-        this.epsilon(child.end, end);
-        return { start, end };
-    }
     star(atom) {
         const start = this.state();
         const end = this.state();
@@ -94,4 +91,3 @@ function freezeState(state) {
         ...(state.accepting === true ? { accepting: true } : {}),
     });
 }
-//# sourceMappingURL=compile.js.map

package/dist/v1/{schema → language}/value/regexp/lower.d.ts

@@ -1,4 +1,3 @@
-import type { JsonSchema } from '../schema.js';
+import type { JsonSchema } from '../model/schema.js';
 /** Creates an Ajv-private schema copy with only checked I-Regexp sources lowered. */
 export declare function lowerIRegexpSchemas(schema: JsonSchema): JsonSchema;
-//# sourceMappingURL=lower.d.ts.map

package/dist/v1/{schema → language}/value/regexp/lower.js

@@ -1,6 +1,6 @@
 import { accept as acceptJsonValue } from '@astrale-os/kernel-dsl/value';
-import { walkSchema } from '../location/walk.js';
-import { isValueObject as isJsonObject } from '../object.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { walkSchema } from '../syntax/walk.js';
 import { lowerIRegexpPattern } from './pattern.js';
 /** Creates an Ajv-private schema copy with only checked I-Regexp sources lowered. */
 export function lowerIRegexpSchemas(schema) {
@@ -24,4 +24,3 @@ export function lowerIRegexpSchemas(schema) {
     });
     return lowered;
 }
-//# sourceMappingURL=lower.js.map

package/dist/v1/{schema → language}/value/regexp/matcher.d.ts

@@ -1,8 +1,7 @@
-import type { Pattern } from '../../compiled/model.js';
+import type { Pattern } from '../compile/model.js';
 export interface IRegexpMatcher {
     test(value: string): boolean;
     matches(value: string): boolean;
 }
 /** Load portable NFA data without a regex engine or dynamic compilation. */
 export declare function loadPattern(pattern: Pattern): IRegexpMatcher;
-//# sourceMappingURL=matcher.d.ts.map

package/dist/v1/{schema → language}/value/regexp/matcher.js

@@ -48,4 +48,3 @@ function accepts(states, active) {
             return true;
     return false;
 }
-//# sourceMappingURL=matcher.js.map

package/dist/v1/{schema → language}/value/regexp/pattern.d.ts

@@ -1,3 +1,2 @@
 /** Lowers one admitted I-Regexp source into the pattern syntax used by the engine. */
 export declare function lowerIRegexpPattern(pattern: string): string;
-//# sourceMappingURL=pattern.d.ts.map

package/dist/v1/{schema → language}/value/regexp/pattern.js

@@ -36,4 +36,3 @@ export function lowerIRegexpPattern(pattern) {
     }
     return result;
 }
-//# sourceMappingURL=pattern.js.map

package/dist/v1/{schema → language}/value/regexp/syntax.d.ts

@@ -1,3 +1,2 @@
 /** Complete RFC 9485 syntax admission through the same AST consumed by compilation. */
 export declare function isIRegexp(source: string): boolean;
-//# sourceMappingURL=syntax.d.ts.map

package/dist/v1/{schema → language}/value/regexp/syntax.js

@@ -3,4 +3,3 @@ import { parseIRegexp } from './ast.js';
 export function isIRegexp(source) {
     return parseIRegexp(source) !== undefined;
 }
-//# sourceMappingURL=syntax.js.map

package/dist/v1/{schema/value → language/value/syntax}/full-match.d.ts

@@ -4,4 +4,3 @@ export type FullMatch = $ZodCheck<string>;
 export declare function fullMatch(source: string): FullMatch;
 /** Compiler-private recognition of checks created by the Schema-owned fullMatch operation. */
 export declare function fullMatchSource(check: unknown): string | undefined;
-//# sourceMappingURL=full-match.d.ts.map

package/dist/v1/{schema/value → language/value/syntax}/full-match.js

@@ -1,14 +1,14 @@
-import { z } from 'zod';
-import { compilePattern } from './regexp/compile.js';
-import { loadPattern } from './regexp/matcher.js';
-import { isIRegexp } from './regexp/syntax.js';
+import { refine } from 'zod';
+import { compilePattern } from '../regexp/compile.js';
+import { loadPattern } from '../regexp/matcher.js';
+import { isIRegexp } from '../regexp/syntax.js';
 const sources = new WeakMap();
 export function fullMatch(source) {
     if (!isIRegexp(source)) {
         throw new TypeError('fullMatch(...) requires a complete RFC 9485 I-Regexp source.');
     }
     const matcher = loadPattern(compilePattern(source));
-    const check = z.refine((value) => matcher.matches(value), {
+    const check = refine((value) => matcher.matches(value), {
         error: `String must fully match I-Regexp ${JSON.stringify(source)}.`,
     });
     sources.set(check, source);
@@ -18,4 +18,3 @@ export function fullMatch(source) {
 export function fullMatchSource(check) {
     return check !== null && typeof check === 'object' ? sources.get(check) : undefined;
 }
-//# sourceMappingURL=full-match.js.map

package/dist/v1/{schema/value/location → language/value/syntax}/keywords.d.ts

@@ -1,4 +1,3 @@
 export declare const SCHEMA_ARRAY_KEYWORDS: Set<string>;
 export declare const SCHEMA_MAP_KEYWORDS: Set<string>;
 export declare const SCHEMA_SINGLE_KEYWORDS: Set<string>;
-//# sourceMappingURL=keywords.d.ts.map

package/dist/v1/{schema/value/location → language/value/syntax}/keywords.js

@@ -18,4 +18,3 @@ export const SCHEMA_SINGLE_KEYWORDS = new Set([
     'unevaluatedItems',
     'unevaluatedProperties',
 ]);
-//# sourceMappingURL=keywords.js.map

package/dist/v1/{schema/value/extensions → language/value/syntax}/node-path/schema.d.ts

@@ -1,6 +1,5 @@
-import type { JsonSchema, JsonSchemaObject } from '../../schema.js';
+import type { JsonSchema, JsonSchemaObject } from '../../model/schema.js';
 export declare const GRAPH_NODE_PATH_SCHEMA_ID: 'https://schemas.astrale.ai/graph/1/node-path';
 /** Exact locally bundled artifact owned by graph/path/language's governed JSON Schema. */
 export declare const graphNodePathSchema: JsonSchemaObject;
 export declare function hasNodePathAnnotation(schema: JsonSchema): boolean;
-//# sourceMappingURL=schema.d.ts.map

package/dist/v1/{schema/value/extensions → language/value/syntax}/node-path/schema.js

@@ -1,5 +1,5 @@
-import { isValueObject as isJsonObject } from '../../object.js';
-import { JSON_SCHEMA_DIALECT } from '../../schema.js';
+import { isValueObject as isJsonObject } from '../../model/object.js';
+import { JSON_SCHEMA_DIALECT } from '../../model/schema.js';
 export const GRAPH_NODE_PATH_SCHEMA_ID = 'https://schemas.astrale.ai/graph/1/node-path';
 /** Exact locally bundled artifact owned by graph/path/language's governed JSON Schema. */
 export const graphNodePathSchema = Object.freeze({
@@ -16,4 +16,3 @@ export function hasNodePathAnnotation(schema) {
         schema.$ref === GRAPH_NODE_PATH_SCHEMA_ID &&
         Object.hasOwn(schema, 'x-astrale-path'));
 }
-//# sourceMappingURL=schema.js.map

package/dist/v1/language/value/syntax/node-path/validate.d.ts

@@ -0,0 +1,4 @@
+import type { ClassRef } from '../../../../addressing/index.js';
+import type { Diagnostic } from '../../../validation/diagnostic.js';
+import type { JsonSchema, ValueSchemaContext } from '../../model/schema.js';
+export declare function validateNodePathExtension(schema: JsonSchema, context: ValueSchemaContext, pointer: string, definitionExists: (ref: ClassRef) => boolean): readonly Diagnostic[];

package/dist/v1/{schema/value/extensions → language/value/syntax}/node-path/validate.js

@@ -1,8 +1,9 @@
-import { diagnostic } from '../../../diagnostic.js';
-import { schemaRefIndex, DOMAIN_ORIGIN_PATTERN, MEMBER_NAME_PATTERN } from '../../../reference.js';
-import { parseJsonPointerFragment } from '../../location/pointer.js';
-import { walkSchema } from '../../location/walk.js';
-import { isValueObject as isJsonObject } from '../../object.js';
+import { Key } from '../../../../addressing/index.js';
+import { DOMAIN_ORIGIN_PATTERN, MEMBER_NAME_PATTERN } from '../../../../addressing/patterns.js';
+import { diagnostic } from '../../../validation/diagnostic.js';
+import { isValueObject as isJsonObject } from '../../model/object.js';
+import { parseJsonPointerFragment } from '../pointer.js';
+import { walkSchema } from '../walk.js';
 import { GRAPH_NODE_PATH_SCHEMA_ID } from './schema.js';
 export function validateNodePathExtension(schema, context, pointer, definitionExists) {
     const diagnostics = [];
@@ -14,15 +15,13 @@ export function validateNodePathExtension(schema, context, pointer, definitionEx
         const tokens = parseJsonPointerFragment(`#${location.pointer}`);
         const fieldName = tokens?.length === 2 && tokens[0] === 'properties' ? tokens[1] : undefined;
         const root = isJsonObject(schema) ? schema : undefined;
-        const directRequiredField = context === 'callable-input' &&
+        const directField = context === 'callable-input' &&
             root?.type === 'object' &&
             location.depth === 1 &&
             location.parentKeyword === 'properties' &&
-            fieldName !== undefined &&
-            Array.isArray(root?.required) &&
-            root.required.includes(fieldName);
-        if (!directRequiredField) {
-            diagnostics.push(diagnostic('VS_PATH_EXTENSION', extensionPointer, 'x-astrale-path is allowed only on a direct required property schema at a callable-input object root.'));
+            fieldName !== undefined;
+        if (!directField) {
+            diagnostics.push(diagnostic('VS_PATH_EXTENSION', extensionPointer, 'x-astrale-path is allowed only on a direct property schema at a callable-input object root.'));
         }
         const schemaKeys = Object.keys(location.schema);
         if (schemaKeys.length !== 2 ||
@@ -42,23 +41,23 @@ export function validateNodePathExtension(schema, context, pointer, definitionEx
             diagnostics.push(diagnostic('VS_PATH_EXTENSION', extensionPointer, 'A V1 Path field resolves exactly one Node.'));
         }
         if (!Array.isArray(annotation.accepts) || annotation.accepts.length === 0) {
-            diagnostics.push(diagnostic('VS_PATH_EXTENSION', `${extensionPointer}/accepts`, 'x-astrale-path.accepts must be a non-empty Node Definition ref set.'));
+            diagnostics.push(diagnostic('VS_PATH_EXTENSION', `${extensionPointer}/accepts`, 'x-astrale-path.accepts must be a non-empty Node Class ref set.'));
             return;
         }
         const seen = new Set();
         annotation.accepts.forEach((candidate, candidateIndex) => {
             const candidatePointer = `${extensionPointer}/accepts/${candidateIndex}`;
             if (!isNodeDefinitionRef(candidate)) {
-                diagnostics.push(diagnostic('VS_PATH_EXTENSION', candidatePointer, 'Path acceptance entries are exact node-family class or interface refs.'));
+                diagnostics.push(diagnostic('VS_PATH_EXTENSION', candidatePointer, 'Path acceptance entries are exact Node Class refs.'));
                 return;
             }
-            const key = schemaRefIndex(candidate);
+            const key = Key.of(candidate);
             if (seen.has(key)) {
-                diagnostics.push(diagnostic('VS_PATH_EXTENSION', candidatePointer, 'x-astrale-path.accepts rejects duplicate Definition refs.'));
+                diagnostics.push(diagnostic('VS_PATH_EXTENSION', candidatePointer, 'x-astrale-path.accepts rejects duplicate Class refs.'));
             }
             seen.add(key);
             if (!definitionExists(candidate)) {
-                diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', candidatePointer, 'Path acceptance Definition is absent from the current/direct exact registry.'));
+                diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', candidatePointer, 'Path acceptance Class is absent from the current/direct exact registry.'));
             }
         });
     });
@@ -69,7 +68,7 @@ function isNodeDefinitionRef(value) {
         hasExactKeys(value, ['origin', 'kind', 'name']) &&
         typeof value.origin === 'string' &&
         DOMAIN_ORIGIN_PATTERN.test(value.origin) &&
-        (value.kind === 'interface' || value.kind === 'class') &&
+        value.kind === 'class' &&
         typeof value.name === 'string' &&
         MEMBER_NAME_PATTERN.test(value.name));
 }
@@ -77,4 +76,3 @@ function hasExactKeys(value, expected) {
     const actual = Object.keys(value);
     return actual.length === expected.length && expected.every((key) => Object.hasOwn(value, key));
 }
-//# sourceMappingURL=validate.js.map

package/dist/v1/{schema/value/location → language/value/syntax}/pointer.d.ts

@@ -2,4 +2,3 @@ export declare function appendPointer(pointer: string, token: string | number):
 export declare function parseJsonPointerFragment(fragment: string): readonly string[] | undefined;
 export declare function tokensToPointer(tokens: readonly string[]): string;
 export declare function resolvePointer(root: unknown, tokens: readonly string[]): unknown;
-//# sourceMappingURL=pointer.d.ts.map

package/dist/v1/{schema/value/location → language/value/syntax}/pointer.js

@@ -46,5 +46,4 @@ export function resolvePointer(root, tokens) {
     }
     return value;
 }
-import { isValueObject as isJsonObject } from '../object.js';
-//# sourceMappingURL=pointer.js.map
+import { isValueObject as isJsonObject } from '../model/object.js';

package/dist/v1/{schema/value/location → language/value/syntax}/walk.d.ts

@@ -1,4 +1,4 @@
-import type { JsonSchema } from '../schema.js';
+import type { JsonSchema } from '../model/schema.js';
 export interface SchemaLocation {
     readonly schema: JsonSchema;
     readonly pointer: string;
@@ -8,4 +8,3 @@ export interface SchemaLocation {
 export declare function walkSchema(schema: JsonSchema, visit: (location: SchemaLocation) => void, pointer?: string): void;
 export declare function collectSchemaPointers(schema: JsonSchema): ReadonlySet<string>;
 export declare function isJsonSchema(value: unknown): value is JsonSchema;
-//# sourceMappingURL=walk.d.ts.map

package/dist/v1/{schema/value/location → language/value/syntax}/walk.js

@@ -1,4 +1,4 @@
-import { isValueObject as isJsonObject } from '../object.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
 import { SCHEMA_ARRAY_KEYWORDS, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS } from './keywords.js';
 import { appendPointer } from './pointer.js';
 export function walkSchema(schema, visit, pointer = '') {
@@ -51,4 +51,3 @@ export function collectSchemaPointers(schema) {
 export function isJsonSchema(value) {
     return typeof value === 'boolean' || isJsonObject(value);
 }
-//# sourceMappingURL=walk.js.map

package/dist/v1/language/view/index.d.ts

@@ -0,0 +1,2 @@
+export type * from './model/view.js';
+export type * from './resolved.js';

package/dist/v1/language/view/index.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,11 @@
+import type { ClassRef, DefinitionBase, ViewRef } from '../../../addressing/index.js';
+export type ViewTarget = {
+    readonly kind: 'domain';
+} | {
+    readonly kind: 'definition';
+    readonly definitions: readonly [ClassRef, ...ClassRef[]];
+};
+export interface ViewDefinition extends DefinitionBase<ViewRef> {
+    readonly description?: string;
+    readonly target: ViewTarget;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,9 @@
+import type { DefinitionKey, ViewRef } from '../../addressing/index.js';
+import type { ViewDefinition, ViewTarget } from './model/view.js';
+export interface ResolvedView {
+    readonly ref: ViewRef;
+    readonly key: DefinitionKey<string, 'view'>;
+    readonly target: ViewTarget;
+    readonly description?: ViewDefinition['description'];
+    readonly definition: ViewDefinition;
+}

package/dist/v1/language/view/resolved.js

@@ -0,0 +1 @@
+export {};

package/dist/v1/schema/admission/accept.d.ts

@@ -0,0 +1,3 @@
+import type { DomainSchemaLookup } from '../dependency/lookup.js';
+import type { DomainSchema } from '../model/schema.js';
+export declare function acceptDomainSchema(input: unknown, lookup?: DomainSchemaLookup): DomainSchema;

package/dist/v1/schema/{domain.accept.js → admission/accept.js}

@@ -1,10 +1,10 @@
 import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, } from '@astrale-os/kernel-dsl/value';
-import { DomainSchemaError, diagnostic } from './diagnostic.js';
-import { emptyDomainSchemaLookup } from './domain.lookup.js';
-import { canonicalDomainSchemaAfterValidation } from './domain.revision.js';
-import { validateDomainSchemaSemantics } from './domain.validate.js';
-import { rememberDomainClosure } from './resolution/closure.js';
-import { routeDomainSchema } from './validation/domain.route.js';
+import { canonicalDomainSchemaAfterValidation } from '../canonical/revision.js';
+import { emptyDomainSchemaLookup } from '../dependency/lookup.js';
+import { SchemaError, diagnostic } from '../diagnostic.js';
+import { rememberDomainClosure } from '../resolution/closure.js';
+import { validateDomainSchemaSemantics } from '../validation/domain.js';
+import { routeDomainSchema } from '../validation/domain.route.js';
 export function acceptDomainSchema(input, lookup = emptyDomainSchemaLookup()) {
     let admitted;
     try {
@@ -12,16 +12,15 @@ export function acceptDomainSchema(input, lookup = emptyDomainSchemaLookup()) {
     }
     catch (error) {
         if (error instanceof JsonBoundaryError) {
-            throw new DomainSchemaError([diagnostic('DV_JSON_VALUE', error.pointer, error.message)]);
+            throw new SchemaError([diagnostic('DV_JSON_VALUE', error.pointer, error.message)]);
         }
         throw error;
     }
     const structured = routeDomainSchema(admitted);
     const validation = validateDomainSchemaSemantics(structured, lookup);
     if (validation.diagnostics.length > 0)
-        throw new DomainSchemaError(validation.diagnostics);
+        throw new SchemaError(validation.diagnostics);
     const accepted = canonicalDomainSchemaAfterValidation(structured).schema;
     rememberDomainClosure(accepted, validation.context.dependencies.values());
     return accepted;
 }
-//# sourceMappingURL=domain.accept.js.map

package/dist/v1/schema/{definition/analysis.d.ts → analysis/class.d.ts}

@@ -1,43 +1,42 @@
-import type { MethodDeclaration } from '../callable.js';
-import type { DomainDiagnostic } from '../diagnostic.js';
-import type { DefinitionRef } from '../reference.js';
+import type { ClassRef } from '../../addressing/index.js';
+import type { MethodDefinition } from '../../language/callable/model/callable.js';
+import type { ClassDefinition } from '../../language/class/model/class.js';
+import type { DataDefinition } from '../../language/class/model/data.js';
+import type { PropertyAuto } from '../../language/class/model/property.js';
+import type { StateTopology } from '../../language/state/index.js';
+import type { JsonSchema } from '../../language/value/model/schema.js';
+import type { SchemaDiagnostic } from '../diagnostic.js';
 import type { DomainResolutionContext } from '../resolution/context.js';
-import type { JsonSchema } from '../value/schema.js';
-import type { ClassDeclaration } from './class.js';
-import type { DataDeclaration } from './data.js';
-import type { InterfaceDeclaration } from './interface.js';
-import type { PropertyAuto } from './property.js';
 import { PropertyKey } from '../../addressing/index.js';
 export interface EffectiveField {
     readonly identity: PropertyKey;
-    readonly owner: DefinitionRef;
+    readonly owner: ClassRef;
     readonly name: string;
     readonly schema: JsonSchema;
     readonly required: boolean;
-    readonly visibility: 'public' | 'private';
     readonly auto?: PropertyAuto;
+    readonly state?: StateTopology;
 }
 export interface EffectiveMethod {
     readonly identity: string;
-    readonly owner: DefinitionRef;
+    readonly owner: ClassRef;
     readonly name: string;
-    readonly declaration: MethodDeclaration;
+    readonly declaration: MethodDefinition;
 }
 export interface EffectiveData {
     readonly identity: string;
-    readonly owner: DefinitionRef;
-    readonly declaration: DataDeclaration;
+    readonly owner: ClassRef;
+    readonly declaration: DataDefinition;
 }
 export interface DefinitionAnalysis {
-    readonly ref: DefinitionRef;
-    readonly declaration: InterfaceDeclaration | ClassDeclaration;
+    readonly ref: ClassRef;
+    readonly declaration: ClassDefinition;
     readonly properties: ReadonlyMap<PropertyKey, EffectiveField>;
     readonly data?: EffectiveData;
     readonly methods: ReadonlyMap<string, EffectiveMethod>;
 }
 export interface DefinitionAnalysisResult {
     readonly definitions: ReadonlyMap<string, DefinitionAnalysis>;
-    readonly diagnostics: readonly DomainDiagnostic[];
+    readonly diagnostics: readonly SchemaDiagnostic[];
 }
 export declare function analyzeDefinitions(environment: DomainResolutionContext): DefinitionAnalysisResult;
-//# sourceMappingURL=analysis.d.ts.map

package/dist/v1/schema/{definition/analysis.js → analysis/class.js}

@@ -1,20 +1,21 @@
 import { json } from '@astrale-os/kernel-dsl/value';
-import { PropertyKey } from '../../addressing/index.js';
+import { Key, PropertyKey } from '../../addressing/index.js';
+import { definitionRefIndex } from '../../addressing/ordering.js';
+import { normalizePolicyChecks } from '../../language/policy/normalization/normalize.js';
+import { canonicalizeValueSchema } from '../../language/value/profile/canonicalize.js';
 import { diagnostic } from '../diagnostic.js';
-import { normalizePolicyChecks } from '../policy/normalize.js';
-import { schemaRefIndex, formatSchemaRef } from '../reference.js';
-import { canonicalizeValueSchema } from '../value/profile/canonicalize.js';
+const formatDefinitionRef = Key.of;
 export function analyzeDefinitions(environment) {
     const diagnostics = [];
     const result = new Map();
     const visiting = new Set();
     const analyze = (ref) => {
-        const key = schemaRefIndex(ref);
+        const key = definitionRefIndex(ref);
         const cached = result.get(key);
         if (cached !== undefined)
             return cached;
         if (visiting.has(key)) {
-            diagnostics.push(diagnostic('DV_INTERFACE_ACYCLIC', '', `Inheritance cycle reaches ${formatSchemaRef(ref)}.`, formatSchemaRef(ref)));
+            diagnostics.push(diagnostic('DV_CLASS_ACYCLIC', '', `Inheritance cycle reaches ${formatDefinitionRef(ref)}.`, formatDefinitionRef(ref)));
             return undefined;
         }
         const resolved = environment.resolveAny(ref);
@@ -22,14 +23,14 @@ export function analyzeDefinitions(environment) {
             return undefined;
         visiting.add(key);
         const declaration = resolved.declaration;
-        const parents = parentRefs(declaration, ref.kind);
+        const parents = declaration.extends;
         const parentAnalyses = parents.flatMap((parent) => {
             const target = environment.resolveAny(parent);
             if (target === undefined) {
-                diagnostics.push(diagnostic('DV_REF_RESOLVES', '', `Inheritance ref ${formatSchemaRef(parent)} does not resolve.`, formatSchemaRef(parent)));
+                diagnostics.push(diagnostic('DV_REF_RESOLVES', '', `Inheritance ref ${formatDefinitionRef(parent)} does not resolve.`, formatDefinitionRef(parent)));
                 return [];
             }
-            const analysis = analyze(target.ref);
+            const analysis = target.ref.kind === 'class' ? analyze(target.ref) : undefined;
             return analysis === undefined ? [] : [analysis];
         });
         const properties = mergeFields(parentAnalyses.map((parent) => parent.properties), ownFields(ref, declaration));
@@ -51,27 +52,18 @@ export function analyzeDefinitions(environment) {
     }
     return Object.freeze({ definitions: result, diagnostics: Object.freeze(diagnostics) });
 }
-function parentRefs(declaration, kind) {
-    if (kind === 'interface') {
-        return declaration.extends;
-    }
-    return declaration.implements;
-}
 function ownFields(owner, declaration) {
-    const root = declaration.properties;
-    const required = new Set(root.required);
     const result = new Map();
-    for (const [name, schema] of Object.entries(root.properties)) {
+    for (const [name, property] of Object.entries(declaration.properties)) {
         const key = PropertyKey.of(owner, name);
-        const metadata = declaration.propertyMetadata[name];
         result.set(key, {
             identity: key,
             owner,
             name,
-            schema,
-            required: required.has(name),
-            visibility: metadata?.visibility === 'private' ? 'private' : 'public',
-            ...(metadata?.auto === undefined ? {} : { auto: metadata.auto }),
+            schema: property.schema,
+            required: property.required,
+            ...(property.auto === undefined ? {} : { auto: property.auto }),
+            ...(property.state === undefined ? {} : { state: property.state }),
         });
     }
     return result;
@@ -99,17 +91,17 @@ function mergeData(owner, declaration, parents, diagnostics) {
             continue;
         }
         if (effective.identity !== parent.data.identity) {
-            diagnostics.push(diagnostic('DV_DATA_COMPOSITION', '', `Data has distinct declaring owners ${formatSchemaRef(effective.owner)} and ${formatSchemaRef(parent.data.owner)}.`));
+            diagnostics.push(diagnostic('DV_DATA_COMPOSITION', '', `Data has distinct declaring owners ${formatDefinitionRef(effective.owner)} and ${formatDefinitionRef(parent.data.owner)}.`));
         }
     }
     const own = 'data' in declaration ? declaration.data : undefined;
     if (own === undefined)
         return effective;
     if (effective !== undefined) {
-        diagnostics.push(diagnostic('DV_DATA_COMPOSITION', '', `Data redeclares the inherited contract from ${formatSchemaRef(effective.owner)}.`));
+        diagnostics.push(diagnostic('DV_DATA_COMPOSITION', '', `Data redeclares the inherited contract from ${formatDefinitionRef(effective.owner)}.`));
     }
     return {
-        identity: `${schemaRefIndex(owner)}\u0000data`,
+        identity: `${definitionRefIndex(owner)}\u0000data`,
         owner,
         declaration: own,
     };
@@ -135,7 +127,7 @@ function mergeMethods(owner, declaration, parents, diagnostics) {
         const parentsForName = inherited.get(name) ?? [];
         for (const parent of parentsForName) {
             if (parent.declaration.inheritance === 'sealed') {
-                diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Method ${name} cannot override sealed ${formatSchemaRef(parent.owner)}.${name}.`));
+                diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Method ${name} cannot override sealed ${formatDefinitionRef(parent.owner)}.${name}.`));
             }
             if (!sameMethodSignature(ownMethod, parent.declaration)) {
                 diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Method ${name} does not exactly preserve its inherited signature.`));
@@ -146,7 +138,7 @@ function mergeMethods(owner, declaration, parents, diagnostics) {
             }
         }
         result.set(name, {
-            identity: `${schemaRefIndex(owner)}\u0000method\u0000${name}`,
+            identity: `${definitionRefIndex(owner)}\u0000method\u0000${name}`,
             owner,
             name,
             declaration: ownMethod,
@@ -158,7 +150,7 @@ function mergeMethods(owner, declaration, parents, diagnostics) {
             diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Inherited method ${name} is ambiguous and has no local override.`));
         }
     }
-    if (owner.kind === 'class' && declaration.family === 'node') {
+    if (declaration.kind === 'node' && !declaration.abstract) {
         for (const [name, method] of result) {
             if (method.declaration.inheritance === 'abstract') {
                 diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Concrete Class ${owner.name} leaves method ${name} abstract.`));
@@ -187,4 +179,3 @@ function canonicalMethodOutput(value) {
 function canonicalPolicy(value) {
     return json.serialize(value === undefined ? null : normalizePolicyChecks(value));
 }
-//# sourceMappingURL=analysis.js.map

package/dist/v1/schema/canonical/domain.d.ts

@@ -1,3 +1,3 @@
-import type { DomainSchemaIR } from '../domain.ir.js';
+import type { DomainSchemaIR } from '../model/schema.js';
+/** Produce the deterministic semantic document consumed by canonical JSON serialization. */
 export declare function canonicalizeDomainSchema(schema: DomainSchemaIR): DomainSchemaIR;
-//# sourceMappingURL=domain.d.ts.map

package/dist/v1/schema/canonical/domain.digest.d.ts

@@ -1,4 +1,3 @@
-import type { Revision } from '../reference.js';
+import type { Revision } from '../../addressing/index.js';
 /** Content-address canonical DomainSchema bytes with the V1 revision algorithm. */
 export declare function digestDomainSchemaBytes(bytes: Uint8Array): Revision;
-//# sourceMappingURL=domain.digest.d.ts.map

package/dist/v1/schema/canonical/domain.digest.js

@@ -1,9 +1,5 @@
-import { sha256 } from '@noble/hashes/sha2.js';
+import { digestRevisionBytes } from '../../addressing/revision.js';
 /** Content-address canonical DomainSchema bytes with the V1 revision algorithm. */
 export function digestDomainSchemaBytes(bytes) {
-    let hexadecimal = '';
-    for (const byte of sha256(bytes))
-        hexadecimal += byte.toString(16).padStart(2, '0');
-    return `sha256:${hexadecimal}`;
+    return digestRevisionBytes(bytes);
 }
-//# sourceMappingURL=domain.digest.js.map