@astrale-os/kernel-dsl 0.2.0-beta.5 → 0.2.0-beta.7

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

@@ -0,0 +1,46 @@
+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<Lazy<import("../../class/authoring.js").NodeClass<import("../../class/authoring.js").NodeClassInput>>, (Readonly<Record<`${string}:class.${string}.property.${string}`, import("../../../language/index.js").PropertyValue>> | Readonly<{} & {
+        [x: string]: unknown;
+    }>) & import("../../../../value/types.js").Object>, CoreRef>;
+    readonly policyObjects: Map<object, PolicyObjectRef>;
+    readonly policyObjectRefs: Set<string>;
+    readonly usedForeignOrigins: Set<string>;
+    constructor(origin: string, dependencies: readonly 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 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,16 @@
-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 { 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();
@@ -32,12 +32,12 @@ export class BuilderContext {
         }
     }
     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 +60,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}.`);
+        if (ref.kind !== 'class') {
+            fail('BUILDER_REFERENCE_KIND', pointer, `Expected class, 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'}.`);
+        const resolvedKind = this.classKind(ref);
+        if (resolvedKind !== kind) {
+            fail('BUILDER_REFERENCE_KIND', pointer, `Expected ${kind} Class, received ${resolvedKind ?? 'an unresolved Class'}.`);
         }
         this.assertVisible(ref, pointer);
         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 +108,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) {
@@ -135,9 +131,9 @@ export class BuilderContext {
             }
             return source.dependency;
         })
-            .sort((left, right) => left.origin.localeCompare(right.origin));
+            .sort((left, right) => compareUnicode(left.origin, right.origin));
     }
-    valueRegistry(currentTypes) {
+    valueRegistry() {
         const directOrigins = new Set(this.#dependencies.keys());
         const closure = new Map();
         for (const { schema } of this.#dependencies.values()) {
@@ -150,17 +146,15 @@ export class BuilderContext {
             origin: schema.origin,
             ...(revision === undefined ? {} : { revision }),
             dependencies: schema.dependencies,
-            types: schema.types,
             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 +163,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 +179,26 @@ 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 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 +210,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 +226,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 +234,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;
+}

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

@@ -1,29 +1,20 @@
 import { accept as acceptJsonValue } from '@astrale-os/kernel-dsl/value';
 import { z } from 'zod';
-import { DomainSchemaError } from '../../schema/diagnostic.js';
-import { compareSchemaRefs } from '../../schema/reference.js';
-import { canonicalizeValueSchema } from '../../schema/value/profile/canonicalize.js';
-import { validateValueSchema } from '../../schema/value/profile/validate.js';
-import { isAuthoringValue } from '../internal/authoring.js';
-import { escapeToken, fail } from '../internal/diagnostic.js';
-import { lowerPathSchema } from './value.path.js';
-import { convertZodToValueSchema, zodObjectPropertyIsOptional } from './value.zod.js';
+import { compareDefinitionRefs } from '../../../addressing/ordering.js';
+import { canonicalizeValueSchema } from '../../../language/value/profile/canonicalize.js';
+import { validateValueSchema } from '../../../language/value/profile/validate.js';
+import { autoPropertyAuthoringInput, propertyAuthoringInput } from '../../class/property.js';
+import { BuilderError } from '../../schema/diagnostic.js';
+import { escapeToken, fail } from '../../schema/diagnostic.js';
+import { isAuthoringValue } from '../../schema/handle.js';
+import { lowerPathSchema } from './path.js';
+import { convertZodToValueSchema, zodObjectPropertyIsOptional } from './zod.js';
 export class BuilderValueSchemas {
     context;
-    types;
     registry;
-    constructor(inputs, context) {
+    constructor(context) {
         this.context = context;
-        const provisional = {};
-        this.registry = context.valueRegistry(provisional);
-        for (const [name, input] of Object.entries(inputs)) {
-            provisional[name] = this.lower(input, 'callable-output', `/types/${escapeToken(name)}`);
-        }
-        for (const [name, schema] of Object.entries(provisional)) {
-            this.assertValid(schema, 'named-type', `/types/${escapeToken(name)}`);
-            provisional[name] = canonicalizeValueSchema(schema, 'named-type', this.registry);
-        }
-        this.types = provisional;
+        this.registry = context.valueRegistry();
     }
     schema(input, placement, pointer) {
         const schema = this.lower(input, 'callable-output', pointer);
@@ -32,41 +23,27 @@ export class BuilderValueSchemas {
     }
     properties(input, pointer) {
         const fields = input ?? {};
-        const compiled = this.facet(fields, 'property-facet', pointer);
-        const metadata = {};
+        const compiled = {};
         for (const [name, value] of Object.entries(fields)) {
-            const automatic = isAutoProperty(value) ? value : undefined;
-            const authored = automatic?.property ?? (isProperty(value) ? value : undefined);
-            if (authored !== undefined &&
-                (authored.visibility === 'private' || automatic !== undefined)) {
-                metadata[name] = {
-                    visibility: authored.visibility,
-                    ...(automatic === undefined ? {} : { auto: automatic.options }),
-                };
-            }
+            const auto = isAutoProperty(value) ? value : undefined;
+            const autoInput = auto === undefined ? undefined : autoPropertyAuthoringInput(auto);
+            const authored = autoInput?.property ?? (isProperty(value) ? value : undefined);
+            const authoredInput = authored === undefined ? undefined : propertyAuthoringInput(authored);
+            const propertyPointer = `${pointer}/${escapeToken(name)}`;
+            const schemaInput = authoredInput === undefined ? value : authoredInput.schema;
+            const schema = this.lower(schemaInput, 'callable-output', `${propertyPointer}/schema`, 'object-property');
+            this.assertValid(schema, 'property-facet', `${propertyPointer}/schema`);
+            compiled[name] = {
+                schema: canonicalizeValueSchema(schema, 'property-facet', this.registry),
+                required: authoredInput?.options.required ?? isRequired(schemaInput),
+                visibility: authoredInput?.options.visibility ?? 'public',
+                ...(autoInput === undefined ? {} : { auto: autoInput.options }),
+                ...(authoredInput?.options.description === undefined
+                    ? {}
+                    : { description: authoredInput.options.description }),
+            };
         }
-        return { properties: compiled, propertyMetadata: metadata };
-    }
-    facet(fields, placement, pointer) {
-        const properties = {};
-        const required = [];
-        for (const [name, input] of Object.entries(fields)) {
-            const propertyPointer = `${pointer}/properties/${escapeToken(name)}`;
-            const automatic = isAutoProperty(input) ? input : undefined;
-            const authoring = automatic?.property ?? (isProperty(input) ? input : undefined);
-            const schemaInput = authoring === undefined ? input : authoring.schema;
-            properties[name] = this.lower(schemaInput, 'callable-output', propertyPointer, 'object-property');
-            if (authoring?.required ?? isRequired(schemaInput))
-                required.push(name);
-        }
-        const schema = {
-            type: 'object',
-            properties,
-            required,
-            additionalProperties: false,
-        };
-        this.assertValid(schema, placement, pointer);
-        return canonicalizeValueSchema(schema, placement, this.registry);
+        return compiled;
     }
     lower(input, conversionContext, pointer, zodPosition = 'value') {
         let schema;
@@ -77,7 +54,7 @@ export class BuilderValueSchemas {
                 override: (context) => lowerPathSchema(context, (accepts, markerPointer) => this.resolvePathAccepts(accepts, markerPointer), pointer),
             });
             if (!converted.ok)
-                throw new DomainSchemaError(converted.diagnostics);
+                throw new BuilderError(converted.diagnostics);
             schema = closeZodObjects(converted.schema);
         }
         else {
@@ -86,7 +63,7 @@ export class BuilderValueSchemas {
         return schema;
     }
     resolvePathAccepts(inputs, pointer) {
-        const refs = inputs.map((input, index) => this.context.resolveNodeDefinition(input, `${pointer}/x-astrale-path/accepts/${index}`));
+        const refs = inputs.map((input, index) => this.context.resolveNodeClass(input, `${pointer}/x-astrale-path/accepts/${index}`));
         const seen = new Set();
         for (const ref of refs) {
             const key = `${ref.origin}\u0000${ref.kind}\u0000${ref.name}`;
@@ -95,12 +72,12 @@ export class BuilderValueSchemas {
             }
             seen.add(key);
         }
-        return refs.sort(compareSchemaRefs);
+        return refs.sort(compareDefinitionRefs);
     }
     assertValid(schema, placement, pointer) {
         const diagnostics = validateValueSchema(schema, placement, this.registry, pointer);
         if (diagnostics.length > 0)
-            throw new DomainSchemaError(diagnostics);
+            throw new BuilderError(diagnostics);
     }
 }
 function closeZodObjects(schema) {
@@ -157,4 +134,3 @@ function isRequired(value) {
         return true;
     return !zodObjectPropertyIsOptional(value);
 }
-//# sourceMappingURL=value.js.map

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

@@ -0,0 +1,3 @@
+import type { NodeClassReferenceInput } from '../../class/authoring.js';
+import type { ZodValueSchemaOverrideContext } from './zod.js';
+export declare function lowerPathSchema(context: ZodValueSchemaOverrideContext, resolveAccepts: (inputs: readonly NodeClassReferenceInput[], pointer: string) => readonly unknown[], pointer: string): void;

package/dist/v1/builder/{compiler/value.path.js → lowering/value/path.js}

@@ -1,4 +1,4 @@
-import { pathAccepts } from '../internal/path.metadata.js';
+import { pathAccepts } from '../../value/path-metadata.js';
 export function lowerPathSchema(context, resolveAccepts, pointer) {
     const inputs = pathAccepts(context.zodSchema);
     if (inputs === undefined)
@@ -18,4 +18,3 @@ export function lowerPathSchema(context, resolveAccepts, pointer) {
 function escapeToken(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }
-//# sourceMappingURL=value.path.js.map

package/dist/v1/builder/{compiler/value.zod.d.ts → lowering/value/zod.d.ts}

@@ -1,14 +1,14 @@
 import { z } from 'zod';
-import type { DomainDiagnostic } from '../../schema/diagnostic.js';
-import type { ValueSchemaRegistry } from '../../schema/value/registry.js';
-import type { JsonSchema, ValueSchemaContext } from '../../schema/value/schema.js';
+import type { JsonSchema, ValueSchemaContext } from '../../../language/value/model/schema.js';
+import type { ValueSchemaRegistry } from '../../../language/value/reference/registry.js';
+import type { BuilderDiagnostic } from '../../schema/diagnostic.js';
 export type ZodValueSchemaConversion = {
     readonly ok: true;
     readonly schema: JsonSchema;
     readonly diagnostics: readonly [];
 } | {
     readonly ok: false;
-    readonly diagnostics: readonly DomainDiagnostic[];
+    readonly diagnostics: readonly BuilderDiagnostic[];
 };
 export interface ZodValueSchemaConversionOptions {
     /** Undefined is representable only as absence at a containing object-property boundary. */
@@ -30,4 +30,3 @@ export interface ZodValueSchemaOverrideContext {
 export declare function convertZodToValueSchema(zodSchema: z.ZodType, context: ValueSchemaContext, registry: ValueSchemaRegistry, pointer?: string, options?: ZodValueSchemaConversionOptions): ZodValueSchemaConversion;
 /** Whether explicit Zod optionality makes a containing object property absent-able. */
 export declare function zodObjectPropertyIsOptional(schema: z.ZodType): boolean;
-//# sourceMappingURL=value.zod.d.ts.map

package/dist/v1/builder/{compiler/value.zod.js → lowering/value/zod.js}

@@ -1,10 +1,10 @@
 import { z } from 'zod';
+import { VALUE_SCHEMA_DIALECT } from '../../../language/value/model/schema.js';
+import { canonicalizeValueSchema } from '../../../language/value/profile/canonicalize.js';
+import { validateValueSchema } from '../../../language/value/profile/validate.js';
+import { isIRegexp } from '../../../language/value/regexp/syntax.js';
+import { fullMatchSource } from '../../../language/value/syntax/full-match.js';
 import { diagnostic } from '../../schema/diagnostic.js';
-import { fullMatchSource } from '../../schema/index.js';
-import { canonicalizeValueSchema } from '../../schema/value/profile/canonicalize.js';
-import { validateValueSchema } from '../../schema/value/profile/validate.js';
-import { isIRegexp } from '../../schema/value/regexp/syntax.js';
-import { VALUE_SCHEMA_DIALECT } from '../../schema/value/schema.js';
 /**
  * Converts only Zod contracts whose JSON-value acceptance is represented
  * without coercion, effects, custom predicates, or format assertions.
@@ -340,4 +340,3 @@ const UNREPRESENTABLE_TYPES = new Set([
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
-//# sourceMappingURL=value.zod.js.map

package/dist/v1/builder/lowering/view.d.ts

@@ -0,0 +1,11 @@
+import type { ViewDefinition } from '../../language/view/model/view.js';
+import type { View } from '../view/authoring.js';
+import type { BuilderContext } from './schema/context.js';
+export interface ViewCompiler {
+    compile(value: View, name: string, pointer: string): ViewDefinition;
+}
+export declare class V1ViewCompiler implements ViewCompiler {
+    readonly context: BuilderContext;
+    constructor(context: BuilderContext);
+    compile(value: View, name: string, pointer: string): ViewDefinition;
+}

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

@@ -1,21 +1,23 @@
-import { compareSchemaRefs } from '../../schema/reference.js';
+import { compareDefinitionRefs } from '../../addressing/ordering.js';
+import { viewAuthoringInput } from '../view/authoring.js';
 export class V1ViewCompiler {
     context;
     constructor(context) {
         this.context = context;
     }
-    compile(value, pointer) {
-        const config = value.config;
+    compile(value, name, pointer) {
+        const config = viewAuthoringInput(value);
         const target = config.target;
         return {
+            ref: { origin: this.context.origin, kind: 'view', name },
             ...(config.description === undefined ? {} : { description: config.description }),
             target: target === undefined || target === 'domain'
                 ? { kind: 'domain' }
                 : {
                     kind: 'definition',
                     definitions: (isTargetList(target) ? target : [target])
-                        .map((entry, index) => this.context.resolveNodeDefinition(entry, `${pointer}/target/definitions/${index}`))
-                        .sort(compareSchemaRefs),
+                        .map((entry, index) => this.context.resolveNodeClass(entry, `${pointer}/target/definitions/${index}`))
+                        .sort(compareDefinitionRefs),
                 },
         };
     }
@@ -23,4 +25,3 @@ export class V1ViewCompiler {
 function isTargetList(input) {
     return Array.isArray(input);
 }
-//# sourceMappingURL=view.js.map

package/dist/v1/builder/{policy.d.ts → policy/authoring.d.ts}

@@ -1,10 +1,11 @@
-import type { PolicyCheckExpression, PolicyPatternExpression, PolicyPatternTerm as CanonicalPolicyPatternTerm } from '../schema/policy/ast.js';
-import type { ClassRef } from '../schema/reference.js';
-import type { EdgeClassAuthoring, NodeClassAuthoring } from './definition.js';
-import type { Lazy } from './internal/authoring.lazy.js';
+import type { ClassRef } from '../../addressing/index.js';
+import type { PolicyCheckExpression, PolicyPatternExpression, PolicyPatternTerm as CanonicalPolicyPatternTerm } from '../../language/policy/model/policy.js';
+import type { EdgeClass, NodeClass } from '../class/authoring.js';
+import type { AuthoringValue } from '../schema/handle.js';
+import type { Lazy } from '../schema/lazy.js';
 export interface PolicyEdgeInput {
     readonly source: CanonicalPolicyPatternTerm;
-    readonly class: Lazy<EdgeClassAuthoring>;
+    readonly class: Lazy<EdgeClass>;
     readonly target: CanonicalPolicyPatternTerm;
     readonly repeat?: {
         readonly min: number;
@@ -12,7 +13,7 @@ export interface PolicyEdgeInput {
     };
 }
 export interface PolicyExistsContext {
-    node(definition: Lazy<NodeClassAuthoring>): CanonicalPolicyPatternTerm;
+    node(definition: Lazy<NodeClass>): CanonicalPolicyPatternTerm;
 }
 export interface PolicyPatternContext {
     readonly subject: CanonicalPolicyPatternTerm;
@@ -28,23 +29,24 @@ export interface MatchPolicyInput {
     readonly description?: string;
     readonly match: (context: PolicyPatternContext) => PolicyPatternExpression;
 }
-export interface PolicyComposition {
+interface PolicyComposition {
     readonly operator: 'allOf' | 'anyOf';
     readonly policies: readonly [PolicyInput, ...PolicyInput[]];
 }
-export interface Policy {
-    readonly input: MatchPolicyInput | PolicyComposition;
+export interface Policy extends AuthoringValue<'policy'> {
 }
 export type PolicyInput = Lazy<Policy>;
-export declare function definePolicy(input: MatchPolicyInput | PolicyComposition): Policy;
-export declare const policy: {
-    readonly allOf: (first: PolicyInput, ...rest: readonly PolicyInput[]) => PolicyComposition;
-    readonly anyOf: (first: PolicyInput, ...rest: readonly PolicyInput[]) => PolicyComposition;
-};
+type PolicyDeclaration = MatchPolicyInput | PolicyComposition;
+export interface PolicyBuilder {
+    (input: MatchPolicyInput): Policy;
+    readonly allOf: (first: PolicyInput, ...rest: readonly PolicyInput[]) => Policy;
+    readonly anyOf: (first: PolicyInput, ...rest: readonly PolicyInput[]) => Policy;
+}
+export declare function policyDeclaration(value: Policy): PolicyDeclaration;
+export declare const policy: PolicyBuilder;
 export declare function createPatternContext(options: {
-    readonly resolveEdgeClass: (value: Lazy<EdgeClassAuthoring>, pointer: string) => ClassRef;
-    readonly resolveNodeClass: (value: Lazy<NodeClassAuthoring>, pointer: string) => ClassRef;
+    readonly resolveEdgeClass: (value: Lazy<EdgeClass>, pointer: string) => ClassRef;
+    readonly resolveNodeClass: (value: Lazy<NodeClass>, pointer: string) => ClassRef;
     readonly pointer: string;
 }): PolicyPatternContext;
 export type { PolicyCheckExpression };
-//# sourceMappingURL=policy.d.ts.map