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

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 { ZodType } from 'zod';
+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,52 +23,45 @@ 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),
+                ...(autoInput === undefined ? {} : { auto: autoInput.options }),
+                ...(authoredInput?.options.description === undefined
+                    ? {}
+                    : { description: authoredInput.options.description }),
+                ...(authoredInput?.machine === undefined
+                    ? {}
+                    : {
+                        state: {
+                            initial: authoredInput.machine.initial,
+                            transitions: authoredInput.machine.transitions,
+                        },
+                    }),
+            };
         }
-        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;
-        if (input instanceof z.ZodType) {
+        if (input instanceof ZodType) {
             const converted = convertZodToValueSchema(input, conversionContext, this.registry, pointer, {
                 position: zodPosition,
                 validate: false,
                 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 +70,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 +79,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) {
@@ -153,8 +137,7 @@ function isAutoProperty(value) {
     return isAuthoringValue(value, 'auto');
 }
 function isRequired(value) {
-    if (!(value instanceof z.ZodType))
+    if (!(value instanceof ZodType))
         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 { ZodType } from 'zod';
+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. */
@@ -19,7 +19,7 @@ export interface ZodValueSchemaConversionOptions {
     readonly validate?: boolean;
 }
 export interface ZodValueSchemaOverrideContext {
-    readonly zodSchema: z.ZodType;
+    readonly zodSchema: ZodType;
     readonly jsonSchema: Record<string, unknown>;
     readonly path: readonly (string | number)[];
 }
@@ -27,7 +27,6 @@ export interface ZodValueSchemaOverrideContext {
  * Converts only Zod contracts whose JSON-value acceptance is represented
  * without coercion, effects, custom predicates, or format assertions.
  */
-export declare function convertZodToValueSchema(zodSchema: z.ZodType, context: ValueSchemaContext, registry: ValueSchemaRegistry, pointer?: string, options?: ZodValueSchemaConversionOptions): ZodValueSchemaConversion;
+export declare function convertZodToValueSchema(zodSchema: 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
+export declare function zodObjectPropertyIsOptional(schema: ZodType): boolean;

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

@@ -1,10 +1,10 @@
-import { z } from 'zod';
+import { ZodObject, ZodType, toJSONSchema } 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 { 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';
-import { fullMatchSource } from '../full-match.js';
 /**
  * Converts only Zod contracts whose JSON-value acceptance is represented
  * without coercion, effects, custom predicates, or format assertions.
@@ -15,19 +15,19 @@ export function convertZodToValueSchema(zodSchema, context, registry, pointer =
         return { ok: false, diagnostics };
     let converted;
     try {
-        const raw = z.toJSONSchema(zodSchema, {
+        const raw = toJSONSchema(zodSchema, {
             target: 'draft-2020-12',
             unrepresentable: 'throw',
             io: 'input',
             cycles: 'ref',
             reused: 'inline',
             override: ({ zodSchema: source, jsonSchema, path }) => {
-                if (source instanceof z.ZodObject) {
+                if (source instanceof ZodObject) {
                     jsonSchema.required = Object.entries(source.shape)
                         .filter(([, property]) => !zodObjectPropertyIsOptional(property))
                         .map(([name]) => name);
                 }
-                if (source instanceof z.ZodType) {
+                if (source instanceof ZodType) {
                     lowerFullMatchChecks(source, jsonSchema);
                     options.override?.({
                         jsonSchema: jsonSchema,
@@ -284,7 +284,7 @@ function getCheckDefinition(value) {
     return isPlainRecord(internals?.def) ? internals.def : undefined;
 }
 function isZodType(value) {
-    return value instanceof z.ZodType;
+    return value instanceof ZodType;
 }
 function escapePointerToken(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
@@ -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,27 +1,27 @@
-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),
                 },
-            auth: config.auth ?? 'required',
         };
     }
 }
 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

package/dist/v1/builder/{policy.js → policy/authoring.js}

@@ -1,20 +1,30 @@
-import { authoringValue, isAuthoringValue } from './internal/authoring.js';
-import { assertKnownKeys, fail } from './internal/diagnostic.js';
-export function definePolicy(input) {
+import { assertKnownKeys, fail } from '../schema/diagnostic.js';
+import { authoringValue } from '../schema/handle.js';
+const declarations = new WeakMap();
+const compositions = new WeakSet();
+export function policyDeclaration(value) {
+    const declaration = declarations.get(value);
+    if (declaration === undefined)
+        fail('BUILDER_POLICY', '/', 'Policies are created by policy(...).');
+    return declaration;
+}
+function createPolicy(input) {
     if ('operator' in input) {
-        if (!isAuthoringValue(input, 'policy-composition')) {
+        if (!compositions.has(input)) {
             fail('BUILDER_POLICY_COMPOSITION', '/', 'Policy compositions are created by policy.allOf(...) or policy.anyOf(...).');
         }
     }
     else {
         assertKnownKeys(input, ['description', 'match']);
     }
-    return authoringValue('policy', { input });
+    const value = authoringValue('policy', {});
+    declarations.set(value, input);
+    return value;
 }
-export const policy = Object.freeze({
-    allOf: (...policies) => composition('allOf', policies),
-    anyOf: (...policies) => composition('anyOf', policies),
-});
+export const policy = Object.freeze(Object.assign(createPolicy, {
+    allOf: (first, ...rest) => createPolicy(composition('allOf', first === undefined ? [] : [first, ...rest])),
+    anyOf: (first, ...rest) => createPolicy(composition('anyOf', first === undefined ? [] : [first, ...rest])),
+}));
 export function createPatternContext(options) {
     let nextVariable = 0;
     const subject = Object.freeze({ kind: 'subject' });
@@ -67,13 +77,14 @@ export function createPatternContext(options) {
 }
 function composition(operator, policies) {
     nonEmpty(policies, `/${operator}`);
-    return authoringValue('policy-composition', {
+    const value = {
         operator,
         policies: [...policies],
-    });
+    };
+    compositions.add(value);
+    return value;
 }
 function nonEmpty(values, pointer) {
     if (values.length === 0)
         fail('BUILDER_POLICY_EMPTY_COMPOSITION', pointer, 'Policy composition must be non-empty.');
 }
-//# sourceMappingURL=policy.js.map

package/dist/v1/builder/schema/define.d.ts

@@ -0,0 +1,11 @@
+import type { Domain } from '../../domain/model/domain.js';
+import type { DomainSchema } from '../../schema/model/schema.js';
+import type { DomainSchemaInput } from './input.js';
+import type { ResolvedDomainOfInput } from './projection.js';
+export type { DomainSchemaInput } from './input.js';
+/** Exact named Schema produced from one authored input. */
+export interface DefinedSchema<Origin extends string, Resolved extends Domain> extends DomainSchema<Origin, Resolved> {
+}
+/** Build and semantically accept one immutable V1 DomainSchema. */
+export declare function defineSchema<const Origin extends string, const Input extends DomainSchemaInput>(origin: Origin, input: Input): DefinedSchema<Origin, ResolvedDomainOfInput<Origin, Input>>;
+export type { ResolvedDomainOfInput } from './projection.js';

package/dist/v1/builder/{schema.js → schema/define.js}

@@ -1,6 +1,5 @@
-import { compileSchema } from './compiler/schema.js';
+import { compileSchema } from '../lowering/schema/compile.js';
 /** Build and semantically accept one immutable V1 DomainSchema. */
 export function defineSchema(origin, input) {
     return compileSchema(origin, input);
 }
-//# sourceMappingURL=schema.js.map

package/dist/v1/builder/schema/diagnostic.d.ts

@@ -0,0 +1,16 @@
+import type { DiagnosticCode as LanguageDiagnosticCode } from '../../language/validation/diagnostic.js';
+export type BuilderDiagnosticCode = LanguageDiagnosticCode | 'BUILDER_ABSTRACT_POLICY' | 'BUILDER_AMBIGUOUS_OWNERSHIP' | 'BUILDER_AUTO_EVENT_INVALID' | 'BUILDER_AUTO_NESTED' | 'BUILDER_AUTO_SET_INVALID' | 'BUILDER_CALLABLE_AUTH' | 'BUILDER_CALLABLE_PLACEMENT' | 'BUILDER_CALLABLE_POLICY_AUTH' | 'BUILDER_CORE_CLASS' | 'BUILDER_CORE_EDGE' | 'BUILDER_CORE_NODE' | 'BUILDER_CORE_PROPERTY' | 'BUILDER_CORE_REF' | 'BUILDER_DEFINITION' | 'BUILDER_DEPENDENCY_CONFLICT' | 'BUILDER_DEPENDENCY_ALIAS' | 'BUILDER_DEPENDENCY_DIRECT' | 'BUILDER_DUPLICATE_MEMBER' | 'BUILDER_FOREIGN_POLICY' | 'BUILDER_FULL_MATCH_INVALID' | 'BUILDER_FUNCTION' | 'BUILDER_METHOD' | 'BUILDER_PATH_DUPLICATE' | 'BUILDER_PATH_EMPTY' | 'BUILDER_POLICY' | 'BUILDER_POLICY_COMPOSITION' | 'BUILDER_POLICY_CYCLE' | 'BUILDER_POLICY_EMPTY_COMPOSITION' | 'BUILDER_POLICY_EMPTY_EXISTS' | 'BUILDER_POLICY_INPUT' | 'BUILDER_POLICY_REF' | 'BUILDER_POLICY_SELF' | 'BUILDER_REFERENCE_CYCLE' | 'BUILDER_REFERENCE_KIND' | 'BUILDER_REFERENCE_MISSING' | 'BUILDER_UNKNOWN_FIELD' | 'BUILDER_UNOWNED_REFERENCE' | 'BUILDER_VIEW' | 'ZOD_SCHEMA_NOT_LOSSLESS';
+export interface BuilderDiagnostic<out Code extends BuilderDiagnosticCode = BuilderDiagnosticCode> {
+    readonly code: Code;
+    readonly pointer: string;
+    readonly message: string;
+    readonly ref?: string;
+}
+export declare function diagnostic<const Code extends BuilderDiagnosticCode>(code: Code, pointer: string, message: string, ref?: string): BuilderDiagnostic<Code>;
+export declare class BuilderError extends Error {
+    readonly diagnostics: readonly BuilderDiagnostic[];
+    constructor(diagnostics: readonly BuilderDiagnostic[]);
+}
+export declare function assertKnownKeys(value: object, allowed: readonly string[], pointer?: string): void;
+export declare function fail(code: BuilderDiagnosticCode, pointer: string, message: string): never;
+export declare function escapeToken(value: string): string;

package/dist/v1/builder/schema/diagnostic.js

@@ -0,0 +1,31 @@
+import { compareUnicode } from '../../addressing/ordering.js';
+export function diagnostic(code, pointer, message, ref) {
+    return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
+}
+export class BuilderError extends Error {
+    diagnostics;
+    constructor(diagnostics) {
+        const ordered = [...diagnostics].sort((left, right) => compareUnicode(left.pointer, right.pointer) ||
+            compareUnicode(left.code, right.code) ||
+            compareUnicode(left.message, right.message));
+        super(ordered
+            .map(({ code, pointer, message }) => `${pointer || '/'} [${code}] ${message}`)
+            .join('\n'));
+        this.name = 'BuilderError';
+        this.diagnostics = Object.freeze(ordered);
+    }
+}
+export function assertKnownKeys(value, allowed, pointer = '') {
+    const accepted = new Set(allowed);
+    for (const key of Object.keys(value)) {
+        if (!accepted.has(key)) {
+            fail('BUILDER_UNKNOWN_FIELD', `${pointer}/${escapeToken(key)}`, `Unknown builder field ${key}.`);
+        }
+    }
+}
+export function fail(code, pointer, message) {
+    throw new BuilderError([diagnostic(code, pointer, message)]);
+}
+export function escapeToken(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}

package/dist/v1/builder/{internal/authoring.d.ts → schema/handle.d.ts}

@@ -1,8 +1,7 @@
 export declare const AUTHORING: unique symbol;
-export type AuthoringKind = 'definition' | 'function' | 'callable-output' | 'policy' | 'view' | 'core-node' | 'core-edge' | 'property' | 'auto' | 'policy-composition';
+export type AuthoringKind = 'definition' | 'function' | 'method' | 'callable-output' | 'policy' | 'view' | 'core-node' | 'core-edge' | 'property' | 'auto';
 export interface AuthoringValue<Kind extends AuthoringKind> {
     readonly [AUTHORING]: Kind;
 }
 export declare function authoringValue<Kind extends AuthoringKind, Value extends object>(kind: Kind, value: Value): Readonly<Value & AuthoringValue<Kind>>;
 export declare function isAuthoringValue<Kind extends AuthoringKind>(value: unknown, kind: Kind): value is AuthoringValue<Kind> & object;
-//# sourceMappingURL=authoring.d.ts.map

package/dist/v1/builder/{internal/authoring.js → schema/handle.js}

@@ -12,4 +12,3 @@ export function isAuthoringValue(value, kind) {
         value !== null &&
         value[AUTHORING] === kind);
 }
-//# sourceMappingURL=authoring.js.map

package/dist/v1/builder/schema/input.d.ts

@@ -0,0 +1,15 @@
+import type { DomainSchema } from '../../schema/model/schema.js';
+import type { Function } from '../callable/authoring.js';
+import type { Class } from '../class/authoring.js';
+import type { CoreInput } from '../core/authoring.js';
+import type { Policy } from '../policy/authoring.js';
+import type { View } from '../view/authoring.js';
+/** Complete authoring input accepted by defineSchema. */
+export interface DomainSchemaInput {
+    readonly dependencies?: Readonly<Record<string, DomainSchema<string>>>;
+    readonly classes?: Readonly<Record<string, Class>>;
+    readonly functions?: Readonly<Record<string, Function>>;
+    readonly policies?: Readonly<Record<string, Policy>>;
+    readonly views?: Readonly<Record<string, View>>;
+    readonly core?: CoreInput;
+}

package/dist/v1/builder/schema/input.js

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

package/dist/v1/builder/{internal/authoring.lazy.d.ts → schema/lazy.d.ts}

@@ -1,3 +1,2 @@
 export type Lazy<T> = T | (() => T);
 export declare function resolveLazy<T>(value: Lazy<T>, pointer: string): T;
-//# sourceMappingURL=authoring.lazy.d.ts.map

package/dist/v1/builder/{internal/authoring.lazy.js → schema/lazy.js}

@@ -11,4 +11,3 @@ export function resolveLazy(value, pointer) {
     }
     return current;
 }
-//# sourceMappingURL=authoring.lazy.js.map