@astrale-os/kernel-dsl 0.1.5 → 0.2.0-beta.10

package/dist/v1/builder/lowering/value/zod.js

@@ -0,0 +1,342 @@
+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';
+/**
+ * Converts only Zod contracts whose JSON-value acceptance is represented
+ * without coercion, effects, custom predicates, or format assertions.
+ */
+export function convertZodToValueSchema(zodSchema, context, registry, pointer = '', options = {}) {
+    const diagnostics = inspectZodSchema(zodSchema, pointer, options.position ?? 'value');
+    if (diagnostics.length > 0)
+        return { ok: false, diagnostics };
+    let converted;
+    try {
+        const raw = z.toJSONSchema(zodSchema, {
+            target: 'draft-2020-12',
+            unrepresentable: 'throw',
+            io: 'input',
+            cycles: 'ref',
+            reused: 'inline',
+            override: ({ zodSchema: source, jsonSchema, path }) => {
+                if (source instanceof z.ZodObject) {
+                    jsonSchema.required = Object.entries(source.shape)
+                        .filter(([, property]) => !zodObjectPropertyIsOptional(property))
+                        .map(([name]) => name);
+                }
+                if (source instanceof z.ZodType) {
+                    lowerFullMatchChecks(source, jsonSchema);
+                    options.override?.({
+                        jsonSchema: jsonSchema,
+                        path,
+                        zodSchema: source,
+                    });
+                }
+            },
+        });
+        converted = copyZodJson(raw);
+        if (converted !== null && typeof converted === 'object' && !Array.isArray(converted)) {
+            converted = { ...converted, $schema: VALUE_SCHEMA_DIALECT };
+        }
+    }
+    catch (error) {
+        return {
+            ok: false,
+            diagnostics: [
+                diagnostic('ZOD_SCHEMA_NOT_LOSSLESS', pointer, `Zod cannot represent this contract exactly as Draft 2020-12: ${errorMessage(error)}.`),
+            ],
+        };
+    }
+    if (options.validate !== false) {
+        const profileDiagnostics = validateValueSchema(converted, context, registry, pointer);
+        if (profileDiagnostics.length > 0)
+            return { ok: false, diagnostics: profileDiagnostics };
+    }
+    return {
+        ok: true,
+        schema: canonicalizeValueSchema(converted, context, registry),
+        diagnostics: [],
+    };
+}
+function copyZodJson(value) {
+    if (value === null || ['boolean', 'number', 'string'].includes(typeof value))
+        return value;
+    if (Array.isArray(value))
+        return value.map(copyZodJson);
+    if (value === null || typeof value !== 'object') {
+        throw new TypeError('Zod emitted a non-JSON schema value.');
+    }
+    const result = {};
+    for (const key of Reflect.ownKeys(value)) {
+        if (typeof key === 'symbol')
+            throw new TypeError('Zod emitted symbol-keyed schema metadata.');
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor === undefined)
+            continue;
+        if (!descriptor.enumerable) {
+            if (key === '~standard')
+                continue;
+            throw new TypeError(`Zod emitted unexpected non-enumerable schema member ${key}.`);
+        }
+        if (!('value' in descriptor))
+            throw new TypeError(`Zod emitted accessor schema member ${key}.`);
+        result[key] = copyZodJson(descriptor.value);
+    }
+    return result;
+}
+/** Whether explicit Zod optionality makes a containing object property absent-able. */
+export function zodObjectPropertyIsOptional(schema) {
+    return hasExplicitOptionality(schema, new Set());
+}
+function inspectZodSchema(root, pointer, position) {
+    const diagnostics = [];
+    const visited = new WeakMap();
+    function inspect(schema, schemaPointer, schemaPosition, boundary) {
+        const visitKey = `${schemaPosition}:${String(boundary)}`;
+        const visits = visited.get(schema) ?? new Set();
+        if (visits.has(visitKey))
+            return;
+        visits.add(visitKey);
+        visited.set(schema, visits);
+        const def = getSchemaDefinition(schema);
+        if (def === undefined) {
+            diagnostics.push(diagnostic('ZOD_SCHEMA_NOT_LOSSLESS', schemaPointer, 'Zod schema has no inspectable v4 definition.'));
+            return;
+        }
+        if (boundary && schemaPosition === 'value' && hasExplicitOptionality(schema, new Set())) {
+            diagnostics.push(diagnostic('ZOD_SCHEMA_NOT_LOSSLESS', schemaPointer, 'Zod optional() accepts JavaScript undefined, which V1 can represent only as absence of a containing object property.'));
+        }
+        const type = typeof def.type === 'string' ? def.type : 'unknown';
+        if (UNREPRESENTABLE_TYPES.has(type)) {
+            diagnostics.push(diagnostic('ZOD_SCHEMA_NOT_LOSSLESS', schemaPointer, `Zod ${type} semantics cannot be represented losslessly in the V1 JSON value domain.`));
+        }
+        if (def.coerce === true) {
+            diagnostics.push(diagnostic('ZOD_SCHEMA_NOT_LOSSLESS', schemaPointer, 'Zod coercion changes the accepted input domain and is not serializable as JSON Schema.'));
+        }
+        inspectCheck(def, schemaPointer, diagnostics);
+        if (Array.isArray(def.checks)) {
+            def.checks.forEach((check, index) => {
+                if (fullMatchSource(check) !== undefined)
+                    return;
+                const checkDef = getCheckDefinition(check);
+                if (checkDef !== undefined) {
+                    inspectCheck(checkDef, `${schemaPointer}/checks/${index}`, diagnostics);
+                }
+            });
+        }
+        for (const child of childSchemas(def, schemaPointer, schemaPosition)) {
+            inspect(child.schema, child.pointer, child.position, child.boundary);
+        }
+    }
+    inspect(root, pointer, position, true);
+    return diagnostics;
+}
+function lowerFullMatchChecks(schema, jsonSchema) {
+    const checks = getSchemaDefinition(schema)?.checks;
+    if (!Array.isArray(checks))
+        return;
+    const admitted = checks.flatMap((check) => {
+        const source = fullMatchSource(check);
+        return source === undefined ? [] : [source];
+    });
+    if (admitted.length === 0)
+        return;
+    if (admitted.length === 1) {
+        jsonSchema.fullMatch = admitted[0];
+        return;
+    }
+    const existing = Array.isArray(jsonSchema.allOf) ? jsonSchema.allOf : [];
+    jsonSchema.allOf = [...existing, ...admitted.map((fullMatch) => ({ fullMatch }))];
+}
+function inspectCheck(def, pointer, diagnostics) {
+    if (def.check === 'custom' || def.check === 'overwrite') {
+        diagnostics.push(diagnostic('ZOD_SCHEMA_NOT_LOSSLESS', pointer, `Zod ${String(def.check)} checks are executable semantics with no lossless JSON Schema form.`));
+        return;
+    }
+    if (def.check === 'string_format' && def.format !== 'regex') {
+        diagnostics.push(diagnostic('ZOD_SCHEMA_NOT_LOSSLESS', pointer, `Zod format ${String(def.format)} asserts acceptance, while V1 format is annotation-only.`));
+        return;
+    }
+    if (def.check === 'string_format' && def.format === 'regex' && def.pattern instanceof RegExp) {
+        if (!isLosslessRegexp(def.pattern)) {
+            diagnostics.push(diagnostic('ZOD_SCHEMA_NOT_LOSSLESS', pointer, 'Zod RegExp flags, anchors, dot semantics, or syntax cannot be preserved as a V1 I-Regexp substring pattern.'));
+        }
+    }
+}
+function childSchemas(def, pointer, position) {
+    const children = [];
+    const samePosition = (candidate, childPointer = pointer) => {
+        if (isZodType(candidate)) {
+            children.push({ boundary: false, pointer: childPointer, position, schema: candidate });
+        }
+    };
+    const nestedValue = (candidate, childPointer) => {
+        if (isZodType(candidate)) {
+            children.push({ boundary: true, pointer: childPointer, position: 'value', schema: candidate });
+        }
+    };
+    switch (def.type) {
+        case 'array':
+            nestedValue(def.element, `${pointer}/items`);
+            break;
+        case 'intersection':
+            samePosition(def.left, `${pointer}/allOf/0`);
+            samePosition(def.right, `${pointer}/allOf/1`);
+            break;
+        case 'lazy':
+            if (typeof def.getter === 'function')
+                samePosition(def.getter());
+            break;
+        case 'object':
+            if (isPlainRecord(def.shape)) {
+                for (const [name, child] of Object.entries(def.shape)) {
+                    if (isZodType(child)) {
+                        children.push({
+                            boundary: true,
+                            pointer: `${pointer}/properties/${escapePointerToken(name)}`,
+                            position: 'object-property',
+                            schema: child,
+                        });
+                    }
+                }
+            }
+            nestedValue(def.catchall, `${pointer}/additionalProperties`);
+            break;
+        case 'record':
+            nestedValue(def.keyType, `${pointer}/propertyNames`);
+            nestedValue(def.valueType, `${pointer}/additionalProperties`);
+            break;
+        case 'tuple':
+            if (Array.isArray(def.items)) {
+                def.items.forEach((item, index) => nestedValue(item, `${pointer}/prefixItems/${index}`));
+            }
+            nestedValue(def.rest, `${pointer}/items`);
+            break;
+        case 'union':
+            if (Array.isArray(def.options)) {
+                def.options.forEach((option, index) => samePosition(option, `${pointer}/anyOf/${index}`));
+            }
+            break;
+        default:
+            samePosition(def.innerType);
+    }
+    return children;
+}
+function hasExplicitOptionality(schema, visiting) {
+    if (visiting.has(schema))
+        return false;
+    visiting.add(schema);
+    const def = getSchemaDefinition(schema);
+    if (def === undefined) {
+        visiting.delete(schema);
+        return false;
+    }
+    let optional = false;
+    switch (def.type) {
+        case 'optional':
+            optional = true;
+            break;
+        case 'default':
+        case 'lazy':
+        case 'nullable': {
+            const child = singleSamePositionChild(def);
+            optional = child !== undefined && hasExplicitOptionality(child, visiting);
+            break;
+        }
+        case 'intersection': {
+            const left = isZodType(def.left) && hasExplicitOptionality(def.left, visiting);
+            const right = isZodType(def.right) && hasExplicitOptionality(def.right, visiting);
+            optional = left && right;
+            break;
+        }
+        case 'union':
+            optional =
+                Array.isArray(def.options) &&
+                    def.options.some((option) => isZodType(option) && hasExplicitOptionality(option, visiting));
+            break;
+        default:
+            optional = false;
+    }
+    visiting.delete(schema);
+    return optional;
+}
+function singleSamePositionChild(def) {
+    const candidate = def.type === 'lazy' && typeof def.getter === 'function' ? def.getter() : def.innerType;
+    return isZodType(candidate) ? candidate : undefined;
+}
+function getSchemaDefinition(value) {
+    return isPlainRecord(value.def) ? value.def : undefined;
+}
+/**
+ * Raw Zod checks do not expose the public `def` available on schemas. This is
+ * the sole private-ABI boundary; Zod is exact-pinned and its behavior is
+ * covered by the focused conversion conformance suite.
+ */
+function getCheckDefinition(value) {
+    if (isZodType(value))
+        return getSchemaDefinition(value);
+    if (value === null || typeof value !== 'object')
+        return undefined;
+    const internals = value._zod;
+    return isPlainRecord(internals?.def) ? internals.def : undefined;
+}
+function isZodType(value) {
+    return value instanceof z.ZodType;
+}
+function escapePointerToken(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}
+function isPlainRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isLosslessRegexp(pattern) {
+    if (pattern.flags !== '' && pattern.flags !== 'u')
+        return false;
+    if (!isIRegexp(pattern.source))
+        return false;
+    let escaped = false;
+    let characterClass = false;
+    for (const character of Array.from(pattern.source)) {
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (character === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (character === '[')
+            characterClass = true;
+        else if (character === ']')
+            characterClass = false;
+        else if (!characterClass && (character === '^' || character === '$' || character === '.')) {
+            return false;
+        }
+    }
+    return true;
+}
+const UNREPRESENTABLE_TYPES = new Set([
+    'bigint',
+    'catch',
+    'custom',
+    'date',
+    'file',
+    'function',
+    'map',
+    'nan',
+    'pipe',
+    'prefault',
+    'promise',
+    'readonly',
+    'set',
+    'symbol',
+    'transform',
+    'undefined',
+    'void',
+]);
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

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/lowering/view.js

@@ -0,0 +1,27 @@
+import { compareDefinitionRefs } from '../../addressing/ordering.js';
+import { viewAuthoringInput } from '../view/authoring.js';
+export class V1ViewCompiler {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    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.resolveNodeClass(entry, `${pointer}/target/definitions/${index}`))
+                        .sort(compareDefinitionRefs),
+                },
+        };
+    }
+}
+function isTargetList(input) {
+    return Array.isArray(input);
+}

package/dist/v1/builder/policy/authoring.d.ts

@@ -0,0 +1,52 @@
+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<EdgeClass>;
+    readonly target: CanonicalPolicyPatternTerm;
+    readonly repeat?: {
+        readonly min: number;
+        readonly max: number;
+    };
+}
+export interface PolicyExistsContext {
+    node(definition: Lazy<NodeClass>): CanonicalPolicyPatternTerm;
+}
+export interface PolicyPatternContext {
+    readonly subject: CanonicalPolicyPatternTerm;
+    readonly object: CanonicalPolicyPatternTerm;
+    readonly source: CanonicalPolicyPatternTerm;
+    readonly target: CanonicalPolicyPatternTerm;
+    edge(input: PolicyEdgeInput): PolicyPatternExpression;
+    exists(build: (context: PolicyExistsContext) => PolicyPatternExpression): PolicyPatternExpression;
+    allOf(first: PolicyPatternExpression, ...rest: readonly PolicyPatternExpression[]): PolicyPatternExpression;
+    anyOf(first: PolicyPatternExpression, ...rest: readonly PolicyPatternExpression[]): PolicyPatternExpression;
+}
+export interface MatchPolicyInput {
+    readonly description?: string;
+    readonly match: (context: PolicyPatternContext) => PolicyPatternExpression;
+}
+interface PolicyComposition {
+    readonly operator: 'allOf' | 'anyOf';
+    readonly policies: readonly [PolicyInput, ...PolicyInput[]];
+}
+export interface Policy extends AuthoringValue<'policy'> {
+}
+export type PolicyInput = Lazy<Policy>;
+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<EdgeClass>, pointer: string) => ClassRef;
+    readonly resolveNodeClass: (value: Lazy<NodeClass>, pointer: string) => ClassRef;
+    readonly pointer: string;
+}): PolicyPatternContext;
+export type { PolicyCheckExpression };

package/dist/v1/builder/policy/authoring.js

@@ -0,0 +1,90 @@
+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 (!compositions.has(input)) {
+            fail('BUILDER_POLICY_COMPOSITION', '/', 'Policy compositions are created by policy.allOf(...) or policy.anyOf(...).');
+        }
+    }
+    else {
+        assertKnownKeys(input, ['description', 'match']);
+    }
+    const value = authoringValue('policy', {});
+    declarations.set(value, input);
+    return value;
+}
+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' });
+    const object = Object.freeze({ kind: 'object' });
+    const source = Object.freeze({ kind: 'source' });
+    const target = Object.freeze({ kind: 'target' });
+    const context = {
+        subject,
+        object,
+        source,
+        target,
+        edge(input) {
+            assertKnownKeys(input, ['source', 'class', 'target', 'repeat']);
+            if (input.repeat !== undefined)
+                assertKnownKeys(input.repeat, ['min', 'max']);
+            return {
+                source: input.source,
+                class: options.resolveEdgeClass(input.class, `${options.pointer}/match/class`),
+                target: input.target,
+                ...(input.repeat === undefined ? {} : { repeat: { ...input.repeat } }),
+            };
+        },
+        exists(build) {
+            const nodes = [];
+            const where = build({
+                node(definition) {
+                    const variable = Object.freeze({ kind: 'variable', id: nextVariable++ });
+                    nodes.push({
+                        variable,
+                        class: options.resolveNodeClass(definition, `${options.pointer}/match/exists/nodes`),
+                    });
+                    return variable;
+                },
+            });
+            if (nodes.length === 0) {
+                fail('BUILDER_POLICY_EMPTY_EXISTS', `${options.pointer}/match/exists/nodes`, 'exists(...) must declare at least one variable Node.');
+            }
+            return { exists: { nodes, where } };
+        },
+        allOf(...expressions) {
+            nonEmpty(expressions, `${options.pointer}/match/allOf`);
+            return { allOf: expressions };
+        },
+        anyOf(...expressions) {
+            nonEmpty(expressions, `${options.pointer}/match/anyOf`);
+            return { anyOf: expressions };
+        },
+    };
+    return Object.freeze(context);
+}
+function composition(operator, policies) {
+    nonEmpty(policies, `/${operator}`);
+    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.');
+}

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/define.js

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

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/schema/handle.d.ts

@@ -0,0 +1,7 @@
+export declare const AUTHORING: unique symbol;
+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;

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

@@ -0,0 +1,14 @@
+export const AUTHORING = Symbol('astrale.v1.authoring');
+export function authoringValue(kind, value) {
+    return Object.freeze(Object.defineProperty({ ...value }, AUTHORING, {
+        configurable: false,
+        enumerable: false,
+        value: kind,
+        writable: false,
+    }));
+}
+export function isAuthoringValue(value, kind) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value[AUTHORING] === kind);
+}

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/schema/lazy.d.ts

@@ -0,0 +1,2 @@
+export type Lazy<T> = T | (() => T);
+export declare function resolveLazy<T>(value: Lazy<T>, pointer: string): T;

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

@@ -0,0 +1,13 @@
+import { fail } from './diagnostic.js';
+export function resolveLazy(value, pointer) {
+    let current = value;
+    const seen = new Set();
+    while (typeof current === 'function') {
+        if (seen.has(current)) {
+            fail('BUILDER_REFERENCE_CYCLE', pointer, 'A lazy reference resolves cyclically.');
+        }
+        seen.add(current);
+        current = current();
+    }
+    return current;
+}