@astrale-os/kernel-dsl 0.2.0-beta.2 → 0.2.0-beta.20

package/dist/v1/builder/lowering/schema/capture.js

@@ -0,0 +1,70 @@
+import { MethodKey } from '../../../addressing/index.js';
+import { classConfiguration } from '../../class/authoring.js';
+import { escapeToken, fail } from '../../schema/diagnostic.js';
+import { isAuthoringValue } from '../../schema/handle.js';
+import { captureCore } from '../core.js';
+import { BuilderContext } from './context.js';
+export function captureSchema(input, context) {
+    captureDefinitions(input.classes ?? {}, context);
+    capturePolicies(input.policies ?? {}, context);
+    captureExecutables(input, context);
+    captureCore(input.core, context);
+}
+export function commitSchemaOwnership(input, origin) {
+    const context = new BuilderContext(origin, input.dependencies ?? {});
+    captureSchema(input, context);
+    context.ownership.commit();
+}
+function captureDefinitions(classes, context) {
+    for (const [name, value] of Object.entries(classes)) {
+        assertDefinition(value, `/classes/${escapeToken(name)}`);
+        context.captureDefinition(value, { origin: context.origin, kind: 'class', name }, `/classes/${escapeToken(name)}`);
+    }
+}
+function capturePolicies(policies, context) {
+    for (const [name, value] of Object.entries(policies)) {
+        if (!isAuthoringValue(value, 'policy')) {
+            fail('BUILDER_POLICY', `/policies/${escapeToken(name)}`, 'Policies are created by policy(...).');
+        }
+        context.capturePolicy(value, { origin: context.origin, kind: 'policy', name }, `/policies/${escapeToken(name)}`);
+    }
+}
+function captureExecutables(input, context) {
+    for (const [name, value] of Object.entries(input.functions ?? {})) {
+        const pointer = `/functions/${escapeToken(name)}`;
+        assertFunction(value, pointer);
+        context.captureFunction(value, { origin: context.origin, kind: 'function', name }, pointer);
+    }
+    for (const [definitionName, definition] of Object.entries(input.classes ?? {})) {
+        if (definition.kind !== 'node')
+            continue;
+        const methods = classConfiguration(definition).methods;
+        for (const [methodName, method] of Object.entries(methods ?? {})) {
+            const pointer = `/classes/${escapeToken(definitionName)}/methods/${escapeToken(methodName)}`;
+            assertMethod(method, pointer);
+            context.ownership.capture(method, MethodKey.of({ origin: context.origin, kind: 'class', name: definitionName }, methodName), pointer);
+        }
+    }
+    for (const [name, value] of Object.entries(input.views ?? {})) {
+        const pointer = `/views/${escapeToken(name)}`;
+        if (!isAuthoringValue(value, 'view')) {
+            fail('BUILDER_VIEW', pointer, 'Views are created by view(...).');
+        }
+        context.captureView(value, { origin: context.origin, kind: 'view', name }, pointer);
+    }
+}
+function assertDefinition(value, pointer) {
+    if (!isAuthoringValue(value, 'definition')) {
+        fail('BUILDER_DEFINITION', pointer, 'Definitions are created by a V1 Definition builder.');
+    }
+}
+function assertFunction(value, pointer) {
+    if (!isAuthoringValue(value, 'function')) {
+        fail('BUILDER_FUNCTION', pointer, 'Functions are created by func(...).');
+    }
+}
+function assertMethod(value, pointer) {
+    if (!isAuthoringValue(value, 'method')) {
+        fail('BUILDER_METHOD', pointer, 'Methods are created by method(...).');
+    }
+}

package/dist/v1/builder/{compiler/schema.d.ts → lowering/schema/compile.d.ts}

@@ -1,10 +1,10 @@
-import type { DomainSchema } from '../../schema/domain.ir.js';
-import type { DomainSchemaInput } from '../schema.input.js';
+import type { DomainSchema } from '../../../schema/model/schema.js';
+import type { DomainSchemaInput } from '../../schema/input.js';
+import type { ResolvedDomainOfInput } from '../../schema/projection.js';
 /**
  * Compile the V1 TypeScript builder graph through the same semantic acceptance
  * path used for untrusted decoded schemas.
  *
  * This is the private implementation behind defineSchema.
  */
-export declare function compileSchema<const Origin extends string, const Input extends DomainSchemaInput>(origin: Origin, input: Input): DomainSchema<Origin, Input>;
-//# sourceMappingURL=schema.d.ts.map
+export declare function compileSchema<const Origin extends string, const Input extends DomainSchemaInput>(origin: Origin, input: Input): DomainSchema<Origin, ResolvedDomainOfInput<Origin, Input>>;

package/dist/v1/builder/{compiler/schema.js → lowering/schema/compile.js}

@@ -1,19 +1,19 @@
-import { canonicalizeDomainSchema } from '../../schema/canonical/domain.js';
-import { deepFreeze } from '../../schema/canonical/freeze.js';
-import { acceptDomainSchema } from '../../schema/domain.accept.js';
-import { MemoryDomainSchemaLookup } from '../../schema/domain.lookup.js';
-import { lookupEntriesForDependencies } from '../../schema/resolution/closure.js';
-import { parseDomainSchemaStructure } from '../../schema/validation/domain.structure.js';
-import { assertKnownKeys, escapeToken } from '../internal/diagnostic.js';
-import { V1CallableCompiler } from './callable.js';
-import { compileCore } from './core.js';
-import { canonicalizeCorePropertyKeys } from './core.properties.js';
-import { V1DefinitionCompiler } from './definition.js';
-import { assertPolicyCompositionAcyclic, V1PolicyCompiler } from './policy.js';
-import { captureSchema, commitSchemaOwnership } from './schema.capture.js';
-import { BuilderContext } from './schema.context.js';
-import { BuilderValueSchemas } from './value.js';
-import { V1ViewCompiler } from './view.js';
+import { acceptDomainSchema } from '../../../schema/admission/accept.js';
+import { canonicalizeDomainSchema } from '../../../schema/canonical/domain.js';
+import { deepFreeze } from '../../../schema/canonical/freeze.js';
+import { MemoryDomainSchemaLookup } from '../../../schema/dependency/lookup.js';
+import { lookupEntriesForDependencies } from '../../../schema/resolution/closure.js';
+import { parseDomainSchemaStructure } from '../../../schema/validation/domain.structure.js';
+import { assertKnownKeys, escapeToken } from '../../schema/diagnostic.js';
+import { V1CallableCompiler } from '../callable.js';
+import { V1DefinitionCompiler } from '../class.js';
+import { canonicalizeCorePropertyKeys } from '../core-properties.js';
+import { compileCore } from '../core.js';
+import { assertPolicyCompositionAcyclic, V1PolicyCompiler } from '../policy.js';
+import { BuilderValueSchemas } from '../value/compile.js';
+import { V1ViewCompiler } from '../view.js';
+import { captureSchema, commitSchemaOwnership } from './capture.js';
+import { BuilderContext } from './context.js';
 /**
  * Compile the V1 TypeScript builder graph through the same semantic acceptance
  * path used for untrusted decoded schemas.
@@ -21,7 +21,7 @@ import { V1ViewCompiler } from './view.js';
  * This is the private implementation behind defineSchema.
  */
 export function compileSchema(origin, input) {
-    const lookup = new MemoryDomainSchemaLookup(lookupEntriesForDependencies(input.dependencies ?? []));
+    const lookup = new MemoryDomainSchemaLookup(lookupEntriesForDependencies(input.dependencies ?? {}));
     const candidate = assembleDomainSchema(origin, input, lookup);
     const accepted = acceptDomainSchema(candidate, lookup);
     commitSchemaOwnership(input, origin);
@@ -29,62 +29,52 @@ export function compileSchema(origin, input) {
 }
 /** Structural assembly before whole-Domain semantic acceptance. */
 function assembleDomainSchema(origin, input, lookup) {
-    assertKnownKeys(input, [
-        'dependencies',
-        'types',
-        'interfaces',
-        'classes',
-        'functions',
-        'policies',
-        'views',
-        'core',
-    ]);
+    assertKnownKeys(input, ['dependencies', 'classes', 'functions', 'policies', 'views', 'core']);
     if (input.core !== undefined)
         assertKnownKeys(input.core, ['nodes', 'edges'], '/core');
-    const context = new BuilderContext(origin, input.dependencies ?? []);
+    const context = new BuilderContext(origin, input.dependencies ?? {});
     captureSchema(input, context);
-    const values = new BuilderValueSchemas(input.types ?? {}, context);
+    const values = new BuilderValueSchemas(context);
     const policyCompiler = new V1PolicyCompiler(context);
     const callableCompiler = new V1CallableCompiler(context, values);
     const definitionCompiler = new V1DefinitionCompiler(context, values, callableCompiler, policyCompiler);
     const viewCompiler = new V1ViewCompiler(context);
-    const interfaces = mapRecord(input.interfaces ?? {}, (value, name) => definitionCompiler.compileInterface(value, `/interfaces/${escapeToken(name)}`));
-    const classes = mapRecord(input.classes ?? {}, (value, name) => definitionCompiler.compileClass(value, `/classes/${escapeToken(name)}`));
+    const classes = mapRecord(input.classes ?? {}, (value, name) => definitionCompiler.compileClass(value, name, `/classes/${escapeToken(name)}`));
     const functions = mapRecord(input.functions ?? {}, (value, name) => callableCompiler.compile(value, {
         kind: 'function',
+        ref: { origin, kind: 'function', name },
         pointer: `/functions/${escapeToken(name)}`,
     }));
-    const policies = mapRecord(input.policies ?? {}, (value, name) => policyCompiler.compile(value, `/policies/${escapeToken(name)}`));
+    const policies = mapRecord(input.policies ?? {}, (value, name) => policyCompiler.compile(value, name, `/policies/${escapeToken(name)}`));
     assertPolicyCompositionAcyclic(policies, origin);
-    const views = mapRecord(input.views ?? {}, (value, name) => viewCompiler.compile(value, `/views/${escapeToken(name)}`));
+    const views = mapRecord(input.views ?? {}, (value, name) => viewCompiler.compile(value, name, `/views/${escapeToken(name)}`));
     const core = compileCore(input.core, context);
     const semanticContent = {
         format: 'astrale.dsl',
         version: 'v1',
         origin,
-        dependencies: [],
-        types: values.types,
-        interfaces,
+        // Class/Property resolution needs every dependency already referenced by
+        // authored Definitions. Core endpoint refs are added immediately below.
+        dependencies: context.dependencies(),
         classes,
         functions,
         policies,
         views,
         core,
     };
-    context.noteDomainReferences(semanticContent);
-    const candidate = {
+    const qualifiedContent = {
         ...semanticContent,
-        dependencies: context.dependencies(),
+        core: canonicalizeCorePropertyKeys(semanticContent, lookup),
     };
-    const lowered = {
-        ...candidate,
-        core: canonicalizeCorePropertyKeys(candidate, lookup),
+    context.noteDomainEndpointReferences(qualifiedContent);
+    const candidate = {
+        ...qualifiedContent,
+        dependencies: context.dependencies(),
     };
-    const structured = parseDomainSchemaStructure(lowered);
+    const structured = parseDomainSchemaStructure(candidate);
     const canonical = parseDomainSchemaStructure(canonicalizeDomainSchema(structured));
     return deepFreeze(canonical);
 }
 function mapRecord(record, map) {
     return Object.fromEntries(Object.entries(record).map(([name, value]) => [name, map(value, name)]));
 }
-//# sourceMappingURL=schema.js.map

package/dist/v1/builder/lowering/schema/context.d.ts

@@ -0,0 +1,44 @@
+import type { CoreRef, ClassRef, DefinitionRef, FunctionRef, PolicyRef, ViewRef } from '../../../addressing/index.js';
+import type { DomainDependency } from '../../../addressing/index.js';
+import type { ClassKind } from '../../../language/class/model/class.js';
+import type { CoreEndpointRef } from '../../../language/core/model/core.js';
+import type { PolicyObjectRef } from '../../../language/policy/model/policy.js';
+import type { ValueSchemaRegistry } from '../../../language/value/reference/registry.js';
+import type { DomainSchema, DomainSchemaIR } from '../../../schema/model/schema.js';
+import type { Function, PolicyObjectInput } from '../../callable/authoring.js';
+import type { Class, ClassReferenceInput } from '../../class/authoring.js';
+import type { CoreNode } from '../../core/authoring.js';
+import type { Policy } from '../../policy/authoring.js';
+import type { View } from '../../view/authoring.js';
+import { type Lazy } from '../../schema/lazy.js';
+import { OwnershipCapture } from './ownership.js';
+export declare class BuilderContext {
+    #private;
+    readonly origin: string;
+    readonly ownership: OwnershipCapture;
+    readonly localDefinitions: Map<string, DefinitionRef<import("../../../addressing/definition-ref.js").Definition.Kind, string>>;
+    readonly localClassKinds: Map<string, ClassKind>;
+    readonly policies: Map<object, PolicyRef>;
+    readonly coreNodes: Map<CoreNode, CoreRef>;
+    readonly policyObjects: Map<object, PolicyObjectRef>;
+    readonly policyObjectRefs: Set<string>;
+    readonly usedForeignOrigins: Set<string>;
+    constructor(origin: string, dependencies: Readonly<Record<string, DomainSchema>>);
+    captureDefinition(value: Class, ref: ClassRef, pointer: string): void;
+    capturePolicy(value: Policy, ref: PolicyRef, pointer: string): void;
+    captureCoreNode(value: CoreNode, slug: string, pointer: string): void;
+    captureFunction(value: Function, ref: FunctionRef, pointer: string): void;
+    captureView(value: View, ref: ViewRef, pointer: string): void;
+    resolveClass(input: ClassReferenceInput, kind: ClassKind, pointer: string): ClassRef;
+    resolveNodeClass(input: ClassReferenceInput, pointer: string): ClassRef;
+    resolveEdgeClass(input: ClassReferenceInput, pointer: string): ClassRef;
+    resolvePolicy(input: Lazy<unknown>, pointer: string): PolicyRef;
+    resolvePolicyObject(input: PolicyObjectInput | PolicyObjectRef, pointer: string): PolicyObjectRef;
+    resolveCoreEndpoint(value: CoreNode | CoreEndpointRef, pointer: string): CoreEndpointRef;
+    dependencies(): Readonly<Record<string, DomainDependency>>;
+    valueRegistry(): ValueSchemaRegistry;
+    noteDomainEndpointReferences(schema: DomainSchemaIR): void;
+    private assertVisible;
+    private classKind;
+    private capturePolicyObject;
+}

package/dist/v1/builder/{compiler/schema.context.js → lowering/schema/context.js}

@@ -1,16 +1,17 @@
-import { revisionOfDomainSchema } from '../../schema/domain.revision.js';
-import { schemaRefIndex, compareSchemaRefs, } from '../../schema/reference.js';
-import { requireDomainClosure } from '../../schema/resolution/closure.js';
-import { collectUsedForeignOrigins } from '../../schema/resolution/origins.js';
-import { graphNodePathSchema } from '../../schema/value/extensions/node-path/schema.js';
-import { resolveLazy } from '../internal/authoring.lazy.js';
-import { fail } from '../internal/diagnostic.js';
-import { OwnershipCapture } from './schema.ownership.js';
+import { compareDefinitionRefs, compareUnicode, definitionRefIndex, } from '../../../addressing/ordering.js';
+import { DEPENDENCY_ALIAS_PATTERN } from '../../../addressing/patterns.js';
+import { graphNodePathSchema } from '../../../language/value/syntax/node-path/schema.js';
+import { revisionOfDomainSchema } from '../../../schema/canonical/revision.js';
+import { requireDomainClosure } from '../../../schema/resolution/closure.js';
+import { collectUsedForeignOrigins } from '../../../schema/resolution/origins.js';
+import { fail } from '../../schema/diagnostic.js';
+import { resolveLazy } from '../../schema/lazy.js';
+import { OwnershipCapture } from './ownership.js';
 export class BuilderContext {
     origin;
     ownership = new OwnershipCapture();
     localDefinitions = new Map();
-    localDefinitionFamilies = new Map();
+    localClassKinds = new Map();
     policies = new Map();
     coreNodes = new Map();
     policyObjects = new Map();
@@ -19,25 +20,32 @@ export class BuilderContext {
     #dependencies = new Map();
     constructor(origin, dependencies) {
         this.origin = origin;
-        for (const schema of dependencies) {
+        for (const [alias, schema] of Object.entries(dependencies)) {
+            const pointer = `/dependencies/${escapePointer(alias)}`;
+            if (!DEPENDENCY_ALIAS_PATTERN.test(alias)) {
+                fail('BUILDER_DEPENDENCY_ALIAS', pointer, `Dependency alias ${JSON.stringify(alias)} must be an ASCII lower-camel identifier.`);
+            }
+            if (alias === '__proto__' || alias === 'prototype' || alias === 'constructor') {
+                fail('BUILDER_DEPENDENCY_ALIAS', pointer, `Dependency alias ${JSON.stringify(alias)} is reserved.`);
+            }
             const dependency = {
                 origin: schema.origin,
                 revision: revisionOfDomainSchema(schema),
             };
             const previous = this.#dependencies.get(schema.origin);
-            if (previous !== undefined && previous.dependency.revision !== dependency.revision) {
-                fail('BUILDER_DEPENDENCY_CONFLICT', '/dependencies', `Dependency ${schema.origin} was supplied at two different revisions.`);
+            if (previous !== undefined) {
+                fail('BUILDER_DEPENDENCY_CONFLICT', pointer, `Dependency origin ${schema.origin} is already declared as alias ${previous.alias}.`);
             }
-            this.#dependencies.set(schema.origin, { schema, dependency });
+            this.#dependencies.set(schema.origin, { alias, schema, dependency });
         }
     }
     captureDefinition(value, ref, pointer) {
-        const key = schemaRefIndex(ref);
+        const key = definitionRefIndex(ref);
         if (this.localDefinitions.has(key)) {
             fail('BUILDER_DUPLICATE_MEMBER', pointer, `Definition ${ref.kind}.${ref.name} is duplicated.`);
         }
         this.localDefinitions.set(key, ref);
-        this.localDefinitionFamilies.set(key, familyOfAuthoring(value));
+        this.localClassKinds.set(key, value.kind);
         this.ownership.captureDefinition(value, ref, pointer);
         this.capturePolicyObject(value, ref);
     }
@@ -60,37 +68,33 @@ export class BuilderContext {
         this.ownership.capture(value, `${ref.origin}:view.${ref.name}`, pointer);
         this.capturePolicyObject(value, ref);
     }
-    resolveDefinition(input, allowed, families, pointer) {
+    resolveClass(input, kind, pointer) {
         const value = resolveLazy(input, pointer);
         const ref = isDefinitionRef(value)
             ? value
-            : typeof value === 'object' && value !== null
-                ? this.ownership.definition(value)
-                : undefined;
+            : isResolvedClass(value)
+                ? value.ref
+                : typeof value === 'object' && value !== null
+                    ? this.ownership.definition(value)
+                    : undefined;
         if (ref === undefined) {
             fail('BUILDER_UNOWNED_REFERENCE', pointer, 'Definition reference has no captured Domain owner.');
         }
-        if (!allowed.includes(ref.kind)) {
-            fail('BUILDER_REFERENCE_KIND', pointer, `Expected ${allowed.join(' or ')}, received ${ref.kind}.`);
-        }
-        const family = this.definitionFamily(ref);
-        if (family === undefined || !families.includes(family)) {
-            fail('BUILDER_REFERENCE_KIND', pointer, `Expected ${families.join(' or ')} family, received ${family ?? 'an unresolved family'}.`);
+        if (ref.kind !== 'class') {
+            fail('BUILDER_REFERENCE_KIND', pointer, `Expected class, received ${ref.kind}.`);
         }
         this.assertVisible(ref, pointer);
+        const resolvedKind = this.classKind(ref);
+        if (resolvedKind !== kind) {
+            fail('BUILDER_REFERENCE_KIND', pointer, `Expected ${kind} Class, received ${resolvedKind ?? 'an unresolved Class'}.`);
+        }
         return { ...ref };
     }
-    resolveNodeDefinition(input, pointer) {
-        return this.resolveDefinition(input, ['interface', 'class'], ['node'], pointer);
-    }
     resolveNodeClass(input, pointer) {
-        return this.resolveDefinition(input, ['class'], ['node'], pointer);
+        return this.resolveClass(input, 'node', pointer);
     }
     resolveEdgeClass(input, pointer) {
-        return this.resolveDefinition(input, ['class'], ['edge'], pointer);
-    }
-    resolveInterface(input, families, pointer) {
-        return this.resolveDefinition(input, ['interface'], families, pointer);
+        return this.resolveClass(input, 'edge', pointer);
     }
     resolvePolicy(input, pointer) {
         const value = resolveLazy(input, pointer);
@@ -112,13 +116,13 @@ export class BuilderContext {
                 : undefined;
         if (ref === undefined ||
             ref.origin !== this.origin ||
-            !this.policyObjectRefs.has(schemaRefIndex(ref))) {
+            !this.policyObjectRefs.has(definitionRefIndex(ref))) {
             fail('BUILDER_POLICY_REF', pointer, 'Policy ref(...) must name one registered local Definition, Function, Policy, View, or Core Node.');
         }
         return { ...ref };
     }
     resolveCoreEndpoint(value, pointer) {
-        if (isDomainRef(value))
+        if (isDomainEndpointRef(value))
             return { kind: 'domain' };
         const ref = isCoreRef(value) ? value : this.coreNodes.get(value);
         if (ref === undefined || ref.origin !== this.origin) {
@@ -127,17 +131,11 @@ export class BuilderContext {
         return { ...ref };
     }
     dependencies() {
-        return [...this.usedForeignOrigins]
-            .map((origin) => {
-            const source = this.#dependencies.get(origin);
-            if (source === undefined) {
-                fail('BUILDER_DEPENDENCY_DIRECT', '/dependencies', `Foreign origin ${origin} is not supplied as an exact direct dependency.`);
-            }
-            return source.dependency;
-        })
-            .sort((left, right) => left.origin.localeCompare(right.origin));
+        return Object.fromEntries([...this.#dependencies.values()]
+            .sort((left, right) => compareUnicode(left.alias, right.alias))
+            .map(({ alias, dependency }) => [alias, dependency]));
     }
-    valueRegistry(currentTypes) {
+    valueRegistry() {
         const directOrigins = new Set(this.#dependencies.keys());
         const closure = new Map();
         for (const { schema } of this.#dependencies.values()) {
@@ -149,18 +147,16 @@ export class BuilderContext {
         const registryDomain = (schema, revision) => ({
             origin: schema.origin,
             ...(revision === undefined ? {} : { revision }),
-            dependencies: schema.dependencies,
-            types: schema.types,
+            dependencies: Object.values(schema.dependencies),
             nodeDefinitions: definitionRefsOf(schema),
         });
         return {
             current: {
                 origin: this.origin,
                 dependencies: [...this.#dependencies.values()].map(({ dependency }) => dependency),
-                types: currentTypes,
                 nodeDefinitions: [...this.localDefinitions.values()]
-                    .filter((ref) => this.localDefinitionFamilies.get(schemaRefIndex(ref)) === 'node')
-                    .sort(compareSchemaRefs),
+                    .filter((ref) => ref.kind === 'class' && this.localClassKinds.get(definitionRefIndex(ref)) === 'node')
+                    .sort(compareDefinitionRefs),
             },
             directDependencies: [...this.#dependencies.values()].map(({ schema, dependency }) => ({
                 ...registryDomain(schema, dependency.revision),
@@ -169,13 +165,13 @@ export class BuilderContext {
             graphNodePath: graphNodePathSchema,
         };
     }
-    noteDomainReferences(schema) {
+    noteDomainEndpointReferences(schema) {
         for (const origin of collectUsedForeignOrigins(schema))
             this.usedForeignOrigins.add(origin);
     }
     assertVisible(ref, pointer) {
         if (ref.origin === this.origin) {
-            if (!this.localDefinitions.has(schemaRefIndex(ref))) {
+            if (!this.localDefinitions.has(definitionRefIndex(ref))) {
                 fail('BUILDER_REFERENCE_MISSING', pointer, `Local Definition ${ref.kind}.${ref.name} is not declared.`);
             }
             return;
@@ -185,22 +181,29 @@ export class BuilderContext {
         }
         this.usedForeignOrigins.add(ref.origin);
     }
-    definitionFamily(ref) {
+    classKind(ref) {
         if (ref.origin === this.origin)
-            return this.localDefinitionFamilies.get(schemaRefIndex(ref));
+            return this.localClassKinds.get(definitionRefIndex(ref));
         const schema = this.#dependencies.get(ref.origin)?.schema;
         if (schema === undefined)
             return undefined;
-        return ref.kind === 'class'
-            ? schema.classes[ref.name]?.family
-            : schema.interfaces[ref.name]?.family;
+        return schema.classes[ref.name]?.kind;
     }
     capturePolicyObject(value, ref) {
         this.policyObjects.set(value, ref);
-        this.policyObjectRefs.add(schemaRefIndex(ref));
+        this.policyObjectRefs.add(definitionRefIndex(ref));
     }
 }
-function isDomainRef(value) {
+function escapePointer(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}
+function isResolvedClass(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const candidate = value;
+    return isDefinitionRef(candidate.ref) && (candidate.kind === 'node' || candidate.kind === 'edge');
+}
+function isDomainEndpointRef(value) {
     if (typeof value !== 'object' || value === null)
         return false;
     const candidate = value;
@@ -212,7 +215,7 @@ function isDefinitionRef(value) {
     const candidate = value;
     return (typeof candidate.origin === 'string' &&
         typeof candidate.name === 'string' &&
-        (candidate.kind === 'interface' || candidate.kind === 'class'));
+        candidate.kind === 'class');
 }
 function isCoreRef(value) {
     if (typeof value !== 'object' || value === null)
@@ -228,8 +231,7 @@ function isPolicyObjectRef(value) {
     const candidate = value;
     return (typeof candidate.origin === 'string' &&
         typeof candidate.name === 'string' &&
-        (candidate.kind === 'interface' ||
-            candidate.kind === 'class' ||
+        (candidate.kind === 'class' ||
             candidate.kind === 'function' ||
             candidate.kind === 'policy' ||
             candidate.kind === 'view' ||
@@ -237,19 +239,9 @@ function isPolicyObjectRef(value) {
 }
 function definitionRefsOf(schema) {
     const refs = [];
-    for (const [name, declaration] of Object.entries(schema.interfaces)) {
-        if (declaration.family === 'node')
-            refs.push({ origin: schema.origin, kind: 'interface', name });
-    }
     for (const [name, declaration] of Object.entries(schema.classes)) {
-        if (declaration.family === 'node')
+        if (declaration.kind === 'node')
             refs.push({ origin: schema.origin, kind: 'class', name });
     }
-    return refs.sort(compareSchemaRefs);
-}
-function familyOfAuthoring(value) {
-    if (value.definitionKind === 'interface')
-        return value.config.family;
-    return value.definitionKind === 'node-class' ? 'node' : 'edge';
+    return refs.sort(compareDefinitionRefs);
 }
-//# sourceMappingURL=schema.context.js.map

package/dist/v1/builder/{compiler/schema.ownership.d.ts → lowering/schema/ownership.d.ts}

@@ -1,4 +1,4 @@
-import type { DefinitionRef } from '../../schema/reference.js';
+import type { DefinitionRef } from '../../../addressing/index.js';
 export declare class OwnershipCapture {
     #private;
     captureDefinition(value: object, ref: DefinitionRef, pointer: string): void;
@@ -6,4 +6,3 @@ export declare class OwnershipCapture {
     definition(value: object): DefinitionRef | undefined;
     commit(): void;
 }
-//# sourceMappingURL=schema.ownership.d.ts.map

package/dist/v1/builder/{compiler/schema.ownership.js → lowering/schema/ownership.js}

@@ -1,4 +1,4 @@
-import { fail } from '../internal/diagnostic.js';
+import { fail } from '../../schema/diagnostic.js';
 const definitionOwners = new WeakMap();
 const semanticOwners = new WeakMap();
 export class OwnershipCapture {
@@ -27,4 +27,3 @@ export class OwnershipCapture {
             definitionOwners.set(value, ref);
     }
 }
-//# sourceMappingURL=schema.ownership.js.map

package/dist/v1/builder/lowering/value/compile.d.ts

@@ -0,0 +1,15 @@
+import type { PropertyRecord } from '../../../language/class/model/property.js';
+import type { JsonSchema, ValueSchemaContext } from '../../../language/value/model/schema.js';
+import type { ValueSchemaRegistry } from '../../../language/value/reference/registry.js';
+import type { PropertyRecordInput, ValueSchemaInput } from '../../class/property.js';
+import type { BuilderContext } from '../schema/context.js';
+export declare class BuilderValueSchemas {
+    readonly context: BuilderContext;
+    readonly registry: ValueSchemaRegistry;
+    constructor(context: BuilderContext);
+    schema(input: ValueSchemaInput, placement: ValueSchemaContext, pointer: string): JsonSchema;
+    properties(input: PropertyRecordInput | undefined, pointer: string): PropertyRecord;
+    private lower;
+    private resolvePathAccepts;
+    private assertValid;
+}