@astrale-os/kernel-dsl 0.2.0-beta.6 → 0.2.0-beta.8

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

@@ -14,4 +14,3 @@ export declare class V1PolicyCompiler implements PolicyCompiler {
     compile(value: Policy, name: string, pointer: string): PolicyDefinition;
 }
 export declare function assertPolicyCompositionAcyclic(declarations: Readonly<Record<string, PolicyDefinition>>, origin: string): void;
-//# sourceMappingURL=policy.d.ts.map

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

@@ -57,4 +57,3 @@ export function assertPolicyCompositionAcyclic(declarations, origin) {
     for (const name of Object.keys(declarations))
         visit(name);
 }
-//# sourceMappingURL=policy.js.map

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

@@ -2,4 +2,3 @@ import type { DomainSchemaInput } from '../../schema/input.js';
 import { BuilderContext } from './context.js';
 export declare function captureSchema(input: DomainSchemaInput, context: BuilderContext): void;
 export declare function commitSchemaOwnership(input: DomainSchemaInput, origin: string): void;
-//# sourceMappingURL=capture.d.ts.map

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

@@ -11,7 +11,7 @@ export function captureSchema(input, context) {
     captureCore(input.core, context);
 }
 export function commitSchemaOwnership(input, origin) {
-    const context = new BuilderContext(origin, input.dependencies ?? []);
+    const context = new BuilderContext(origin, input.dependencies ?? {});
     captureSchema(input, context);
     context.ownership.commit();
 }
@@ -68,4 +68,3 @@ function assertMethod(value, pointer) {
         fail('BUILDER_METHOD', pointer, 'Methods are created by method(...).');
     }
 }
-//# sourceMappingURL=capture.js.map

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

@@ -8,4 +8,3 @@ import type { DomainOfInput } from '../../schema/projection.js';
  * 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, DomainOfInput<Origin, Input>>;
-//# sourceMappingURL=compile.d.ts.map

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

@@ -21,7 +21,7 @@ import { BuilderContext } from './context.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);
@@ -32,7 +32,7 @@ function assembleDomainSchema(origin, input, lookup) {
     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(context);
     const policyCompiler = new V1PolicyCompiler(context);
@@ -78,4 +78,3 @@ function assembleDomainSchema(origin, input, lookup) {
 function mapRecord(record, map) {
     return Object.fromEntries(Object.entries(record).map(([name, value]) => [name, map(value, name)]));
 }
-//# sourceMappingURL=compile.js.map

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

@@ -5,11 +5,11 @@ 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 { FunctionAuthoring, PolicyObjectInput } from '../../callable/authoring.js';
-import type { ClassAuthoring, ClassReferenceInput } from '../../class/authoring.js';
-import type { CoreNodeAuthoring } from '../../core/authoring.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 { ViewAuthoring } from '../../view/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 {
@@ -19,29 +19,28 @@ export declare class BuilderContext {
     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<CoreNodeAuthoring<Lazy<import("../../class/authoring.js").NodeClassAuthoring<import("../../class/authoring.js").NodeClassInput>>, (Readonly<Record<`${string}:class.${string}.property.${string}`, import("../../../language/index.js").PropertyValue>> | Readonly<{} & {
+    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: ClassAuthoring, ref: ClassRef, pointer: string): void;
+    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: CoreNodeAuthoring, slug: string, pointer: string): void;
-    captureFunction(value: FunctionAuthoring, ref: FunctionRef, pointer: string): void;
-    captureView(value: ViewAuthoring, ref: ViewRef, 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: CoreNodeAuthoring | CoreEndpointRef, pointer: string): CoreEndpointRef;
-    dependencies(): readonly DomainDependency[];
+    resolveCoreEndpoint(value: CoreNode | CoreEndpointRef, pointer: string): CoreEndpointRef;
+    dependencies(): Readonly<Record<string, DomainDependency>>;
     valueRegistry(): ValueSchemaRegistry;
     noteDomainEndpointReferences(schema: DomainSchemaIR): void;
     private assertVisible;
     private classKind;
     private capturePolicyObject;
 }
-//# sourceMappingURL=context.d.ts.map

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

@@ -1,4 +1,5 @@
 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';
@@ -19,16 +20,23 @@ 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) {
@@ -75,11 +83,11 @@ export class BuilderContext {
         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'}.`);
         }
-        this.assertVisible(ref, pointer);
         return { ...ref };
     }
     resolveNodeClass(input, pointer) {
@@ -123,15 +131,9 @@ 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) => compareUnicode(left.origin, right.origin));
+        return Object.fromEntries([...this.#dependencies.values()]
+            .sort((left, right) => compareUnicode(left.alias, right.alias))
+            .map(({ alias, dependency }) => [alias, dependency]));
     }
     valueRegistry() {
         const directOrigins = new Set(this.#dependencies.keys());
@@ -145,7 +147,7 @@ export class BuilderContext {
         const registryDomain = (schema, revision) => ({
             origin: schema.origin,
             ...(revision === undefined ? {} : { revision }),
-            dependencies: schema.dependencies,
+            dependencies: Object.values(schema.dependencies),
             nodeDefinitions: definitionRefsOf(schema),
         });
         return {
@@ -192,6 +194,9 @@ export class BuilderContext {
         this.policyObjectRefs.add(definitionRefIndex(ref));
     }
 }
+function escapePointer(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}
 function isResolvedClass(value) {
     if (typeof value !== 'object' || value === null)
         return false;
@@ -240,4 +245,3 @@ function definitionRefsOf(schema) {
     }
     return refs.sort(compareDefinitionRefs);
 }
-//# sourceMappingURL=context.js.map

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

@@ -6,4 +6,3 @@ export declare class OwnershipCapture {
     definition(value: object): DefinitionRef | undefined;
     commit(): void;
 }
-//# sourceMappingURL=ownership.d.ts.map

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

@@ -27,4 +27,3 @@ export class OwnershipCapture {
             definitionOwners.set(value, ref);
     }
 }
-//# sourceMappingURL=ownership.js.map

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

@@ -13,4 +13,3 @@ export declare class BuilderValueSchemas {
     private resolvePathAccepts;
     private assertValid;
 }
-//# sourceMappingURL=compile.d.ts.map

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

@@ -134,4 +134,3 @@ function isRequired(value) {
         return true;
     return !zodObjectPropertyIsOptional(value);
 }
-//# sourceMappingURL=compile.js.map

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

@@ -1,4 +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;
-//# sourceMappingURL=path.d.ts.map

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

@@ -18,4 +18,3 @@ export function lowerPathSchema(context, resolveAccepts, pointer) {
 function escapeToken(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }
-//# sourceMappingURL=path.js.map

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

@@ -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=zod.d.ts.map

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

@@ -340,4 +340,3 @@ const UNREPRESENTABLE_TYPES = new Set([
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
-//# sourceMappingURL=zod.js.map

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

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

package/dist/v1/builder/lowering/view.js

@@ -25,4 +25,3 @@ export class V1ViewCompiler {
 function isTargetList(input) {
     return Array.isArray(input);
 }
-//# sourceMappingURL=view.js.map

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

@@ -1,11 +1,11 @@
 import type { ClassRef } from '../../addressing/index.js';
 import type { PolicyCheckExpression, PolicyPatternExpression, PolicyPatternTerm as CanonicalPolicyPatternTerm } from '../../language/policy/model/policy.js';
-import type { EdgeClassAuthoring, NodeClassAuthoring } from '../class/authoring.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;
@@ -13,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;
@@ -45,9 +45,8 @@ export interface PolicyBuilder {
 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=authoring.d.ts.map

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

@@ -88,4 +88,3 @@ function nonEmpty(values, pointer) {
     if (values.length === 0)
         fail('BUILDER_POLICY_EMPTY_COMPOSITION', pointer, 'Policy composition must be non-empty.');
 }
-//# sourceMappingURL=authoring.js.map

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

@@ -2,7 +2,9 @@ import type { DomainSchema } from '../../schema/model/schema.js';
 import type { DomainSchemaInput } from './input.js';
 import type { DomainOfInput } from './projection.js';
 export type { DomainSchemaInput } from './input.js';
+/** Exact named Schema produced from one authored input. */
+export interface DefinedSchema<Origin extends string, Input extends DomainSchemaInput> extends DomainSchema<Origin, Input, DomainOfInput<Origin, Input>> {
+}
 /** Build and semantically accept one immutable V1 DomainSchema. */
-export declare function defineSchema<const Origin extends string, const Input extends DomainSchemaInput>(origin: Origin, input: Input): DomainSchema<Origin, Input, DomainOfInput<Origin, Input>>;
-export type { DomainOfInput } from './projection.js';
-//# sourceMappingURL=define.d.ts.map
+export declare function defineSchema<const Origin extends string, const Input extends DomainSchemaInput>(origin: Origin, input: Input): DefinedSchema<Origin, Input>;
+export type { DirectDependenciesOf, DomainOfInput } from './projection.js';

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

@@ -3,4 +3,3 @@ import { compileSchema } from '../lowering/schema/compile.js';
 export function defineSchema(origin, input) {
     return compileSchema(origin, input);
 }
-//# sourceMappingURL=define.js.map

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

@@ -1,5 +1,5 @@
 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_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 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;
@@ -14,4 +14,3 @@ export declare class BuilderError extends Error {
 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;
-//# sourceMappingURL=diagnostic.d.ts.map

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

@@ -29,4 +29,3 @@ export function fail(code, pointer, message) {
 export function escapeToken(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }
-//# sourceMappingURL=diagnostic.js.map

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

@@ -5,4 +5,3 @@ export interface AuthoringValue<Kind extends AuthoringKind> {
 }
 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=handle.d.ts.map

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

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

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

@@ -1,16 +1,15 @@
 import type { DomainSchema } from '../../schema/model/schema.js';
-import type { FunctionAuthoring } from '../callable/authoring.js';
-import type { ClassAuthoring } from '../class/authoring.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 { ViewAuthoring } from '../view/authoring.js';
+import type { View } from '../view/authoring.js';
 /** Complete authoring input accepted by defineSchema. */
 export interface DomainSchemaInput {
-    readonly dependencies?: readonly DomainSchema<string, unknown>[];
-    readonly classes?: Readonly<Record<string, ClassAuthoring>>;
-    readonly functions?: Readonly<Record<string, FunctionAuthoring>>;
+    readonly dependencies?: Readonly<Record<string, DomainSchema<string, unknown>>>;
+    readonly classes?: Readonly<Record<string, Class>>;
+    readonly functions?: Readonly<Record<string, Function>>;
     readonly policies?: Readonly<Record<string, Policy>>;
-    readonly views?: Readonly<Record<string, ViewAuthoring>>;
+    readonly views?: Readonly<Record<string, View>>;
     readonly core?: CoreInput;
 }
-//# sourceMappingURL=input.d.ts.map

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

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=input.js.map

package/dist/v1/builder/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=lazy.d.ts.map

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

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

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

@@ -3,12 +3,13 @@ import type { z } from 'zod';
 import type { Revision } from '../../addressing/index.js';
 import type * as domain from '../../domain/model/domain.js';
 import type * as language from '../../language/index.js';
-import type { FunctionAuthoring, MethodAuthoring, StreamOutput, BinaryOutput } from '../callable/authoring.js';
-import type { ClassAuthoring, DirectedEdgeClassAuthoring, NodeClassAuthoring, UndirectedEdgeClassAuthoring } from '../class/authoring.js';
-import type { AutoPropertyAuthoring, PropertyAuthoring, PropertyOptions, ValueSchemaInput } from '../class/property.js';
+import type { DomainOfSchema, DomainSchema } from '../../schema/model/schema.js';
+import type { Function, Method, StreamOutput, BinaryOutput } from '../callable/authoring.js';
+import type { Class, DirectedEdgeClass, NodeClass, UndirectedEdgeClass } from '../class/authoring.js';
+import type { AutoProperty, Property, PropertyOptions, ValueSchemaInput } from '../class/property.js';
 import type { TypedValueSchema } from '../value/schema.js';
 import type { DomainSchemaInput } from './input.js';
-export type DomainOfInput<Origin extends string, Input extends DomainSchemaInput> = domain.Domain<{
+export type DomainOfInput<Origin extends string, Input extends DomainSchemaInput> = Omit<domain.Domain<{
     readonly [Name in keyof ClassesInputOf<Input>]: ResolvedClassOfAuthoring<Origin, Extract<Name, string>, ClassesInputOf<Input>[Name], Input>;
 }, {
     readonly [Name in keyof FunctionsInputOf<Input>]: ResolvedFunctionOfAuthoring<Origin, Extract<Name, string>, FunctionsInputOf<Input>[Name]>;
@@ -33,13 +34,23 @@ export type DomainOfInput<Origin extends string, Input extends DomainSchemaInput
         };
         readonly key: language.DefinitionKey<Origin, 'core', Extract<Name, string>>;
     };
-}, Revision>;
-export type ResolvedClassOfAuthoring<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput, Seen = Value> = Value extends NodeClassAuthoring ? language.ResolvedClass<'node', PropertyCollectionOf<Origin, EffectivePropertyEntries<Value>, Root>, MethodCollectionOf<Origin, EffectiveMethodEntries<Value, false>, Root>, MethodCollectionOf<Origin, EffectiveMethodEntries<Value, true>, Root>, PropertyCollectionOf<Origin, OwnPropertyEntries<Value>, Root>, MethodCollectionOf<Origin, OwnMethodEntries<Value, false>, Root>, MethodCollectionOf<Origin, OwnMethodEntries<Value, true>, Root>, Extract<ProjectedClassDefinition<Origin, Name, Value>, language.NodeClassDefinition>, ResolvedParentsOf<Origin, Value, Root, Seen>> & {
+}, Revision>, 'dependencies'> & {
+    readonly dependencies: domain.DependencyDomainNamespace<DirectDependenciesOf<Input>>;
+};
+type DependenciesInputOf<Input extends DomainSchemaInput> = RecordField<Input, 'dependencies'>;
+/**
+ * Project exact direct witnesses already carried by dependency Schemas.
+ * This intentionally never reopens their authored inputs or computes a typed closure.
+ */
+export type DirectDependenciesOf<Input extends DomainSchemaInput> = {
+    readonly [Alias in keyof DependenciesInputOf<Input>]: DependenciesInputOf<Input>[Alias] extends infer Dependency extends DomainSchema ? DomainOfSchema<Dependency> : never;
+};
+export type ResolvedClassOfAuthoring<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput, Seen = Value> = Value extends NodeClass ? language.ResolvedClass<'node', PropertyCollectionOf<Origin, EffectivePropertyEntries<Value>, Root>, MethodCollectionOf<Origin, EffectiveMethodEntries<Value, false>, Root>, MethodCollectionOf<Origin, EffectiveMethodEntries<Value, true>, Root>, PropertyCollectionOf<Origin, OwnPropertyEntries<Value>, Root>, MethodCollectionOf<Origin, OwnMethodEntries<Value, false>, Root>, MethodCollectionOf<Origin, OwnMethodEntries<Value, true>, Root>, Extract<ProjectedClassDefinition<Origin, Name, Value>, language.NodeClassDefinition>, ResolvedParentsOf<Origin, Value, Root, Seen>> & {
     readonly ref: language.ClassRef<Name> & {
         readonly origin: Origin;
     };
     readonly key: language.DefinitionKey<Origin, 'class', Name>;
-} : Value extends DirectedEdgeClassAuthoring | UndirectedEdgeClassAuthoring ? language.ResolvedClass<'edge', PropertyCollectionOf<Origin, EffectivePropertyEntries<Value>, Root>, EmptyMethodCollection, EmptyMethodCollection, PropertyCollectionOf<Origin, OwnPropertyEntries<Value>, Root>, EmptyMethodCollection, EmptyMethodCollection, Extract<ProjectedClassDefinition<Origin, Name, Value>, language.EdgeClassDefinition>, ResolvedParentsOf<Origin, Value, Root, Seen>> & {
+} : Value extends DirectedEdgeClass | UndirectedEdgeClass ? language.ResolvedClass<'edge', PropertyCollectionOf<Origin, EffectivePropertyEntries<Value>, Root>, EmptyMethodCollection, EmptyMethodCollection, PropertyCollectionOf<Origin, OwnPropertyEntries<Value>, Root>, EmptyMethodCollection, EmptyMethodCollection, Extract<ProjectedClassDefinition<Origin, Name, Value>, language.EdgeClassDefinition>, ResolvedParentsOf<Origin, Value, Root, Seen>> & {
     readonly ref: language.ClassRef<Name> & {
         readonly origin: Origin;
     };
@@ -52,13 +63,13 @@ type AbstractOf<Config> = Config extends {
 type ConstraintsOf<Options> = Options extends {
     readonly constraints?: infer Constraints;
 } ? NonNullable<Constraints> : Record<never, never>;
-type ProjectedClassDefinition<Origin extends string, Name extends string, Value> = Value extends NodeClassAuthoring<infer Config> ? language.NodeClassDefinition & {
+type ProjectedClassDefinition<Origin extends string, Name extends string, Value> = Value extends NodeClass<infer Config> ? language.NodeClassDefinition & {
     readonly ref: language.ClassRef<Name> & {
         readonly origin: Origin;
     };
     readonly kind: 'node';
     readonly abstract: AbstractOf<Config>;
-} : Value extends DirectedEdgeClassAuthoring<infer Input> ? language.EdgeClassDefinition & {
+} : Value extends DirectedEdgeClass<infer Input> ? language.EdgeClassDefinition & {
     readonly ref: language.ClassRef<Name> & {
         readonly origin: Origin;
     };
@@ -76,7 +87,7 @@ type ProjectedClassDefinition<Origin extends string, Name extends string, Value>
         };
     };
     readonly constraints: language.DirectedEdgeConstraints & ConstraintsOf<Input>;
-} : Value extends UndirectedEdgeClassAuthoring<infer Input> ? language.EdgeClassDefinition & {
+} : Value extends UndirectedEdgeClass<infer Input> ? language.EdgeClassDefinition & {
     readonly ref: language.ClassRef<Name> & {
         readonly origin: Origin;
     };
@@ -105,14 +116,14 @@ type CoreInputOf<Input extends DomainSchemaInput> = Input extends {
 } ? NonNullable<CoreValue> : Record<never, never>;
 type CoreNodesInputOf<Input extends DomainSchemaInput> = RecordField<CoreInputOf<Input>, 'nodes'>;
 type ResolveLazy<Value, Depth extends readonly unknown[] = []> = Depth['length'] extends 32 ? Value : Value extends () => infer Resolved ? ResolveLazy<Resolved, readonly [...Depth, unknown]> : Value;
-type ClassInputOf<Value> = Value extends NodeClassAuthoring<infer Input> ? Input : Value extends DirectedEdgeClassAuthoring<infer Input> ? Input : Value extends UndirectedEdgeClassAuthoring<infer Input> ? Input : never;
+type ClassInputOf<Value> = Value extends NodeClass<infer Input> ? Input : Value extends DirectedEdgeClass<infer Input> ? Input : Value extends UndirectedEdgeClass<infer Input> ? Input : never;
 type ParentsOf<Value> = ClassInputOf<Value> extends {
     readonly extends?: readonly (infer Parent)[];
 } ? ResolveLazy<Parent> : never;
 type ParentInputsOf<Value> = ClassInputOf<Value> extends {
     readonly extends?: infer Parents extends readonly unknown[];
 } ? Parents : readonly [];
-type ResolvedParentOf<Origin extends string, Parent, Root extends DomainSchemaInput, Seen> = ResolveLazy<Parent> extends infer Resolved ? Resolved extends language.ResolvedClass ? Resolved : LocalNameOf<Root, Resolved> extends infer Name extends string ? Resolved extends Seen ? Resolved extends NodeClassAuthoring ? language.ResolvedClass<'node'> & {
+type ResolvedParentOf<Origin extends string, Parent, Root extends DomainSchemaInput, Seen> = ResolveLazy<Parent> extends infer Resolved ? Resolved extends language.ResolvedClass ? Resolved : LocalNameOf<Root, Resolved> extends infer Name extends string ? Resolved extends Seen ? Resolved extends NodeClass ? language.ResolvedClass<'node'> & {
     readonly key: language.DefinitionKey<Origin, 'class', Name>;
 } : language.ResolvedClass<'edge'> & {
     readonly key: language.DefinitionKey<Origin, 'class', Name>;
@@ -135,16 +146,16 @@ interface AuthoredPropertyEntry<Owner, Name extends string, Field> {
 type OwnPropertyEntries<Value> = {
     [Name in keyof PropertyFieldsOf<Value>]: AuthoredPropertyEntry<Value, Extract<Name, string>, PropertyFieldsOf<Value>[Name]>;
 }[keyof PropertyFieldsOf<Value>];
-type ParentPropertyEntries<Parent, Seen> = Parent extends language.ResolvedClass ? language.PropertiesOf<Parent>['byKey'][keyof language.PropertiesOf<Parent>['byKey']] : Parent extends ClassAuthoring ? EffectivePropertyEntries<Parent, Seen> : never;
+type ParentPropertyEntries<Parent, Seen> = Parent extends language.ResolvedClass ? language.PropertiesOf<Parent>['byKey'][keyof language.PropertiesOf<Parent>['byKey']] : Parent extends Class ? EffectivePropertyEntries<Parent, Seen> : never;
 type EffectivePropertyEntries<Value, Seen = never> = Value extends Seen ? never : OwnPropertyEntries<Value> | (ParentsOf<Value> extends infer Parent ? Parent extends unknown ? ParentPropertyEntries<Parent, Seen | Value> : never : never);
-type PropertySchemaOf<Field> = Field extends AutoPropertyAuthoring<infer Value> ? PropertySchemaOf<Value> : Field extends PropertyAuthoring<infer Schema, PropertyOptions> ? Schema : Field;
-type PropertyOptionsOf<Field> = Field extends AutoPropertyAuthoring<infer Value> ? PropertyOptionsOf<Value> : Field extends PropertyAuthoring<ValueSchemaInput, infer Options> ? Options : Record<never, never>;
+type PropertySchemaOf<Field> = Field extends AutoProperty<infer Value> ? PropertySchemaOf<Value> : Field extends Property<infer Schema, PropertyOptions> ? Schema : Field;
+type PropertyOptionsOf<Field> = Field extends AutoProperty<infer Value> ? PropertyOptionsOf<Value> : Field extends Property<ValueSchemaInput, infer Options> ? Options : Record<never, never>;
 type ValueOutputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.output<Schema> : PortableValue;
 type ValueInputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : PortableValue;
 type PropertyRequiredOf<Field> = PropertyOptionsOf<Field> extends {
     readonly required: infer Required extends boolean;
 } ? Required : undefined extends ValueInputOf<PropertySchemaOf<Field>> ? false : true;
-export type CorePropertyInput<ClassValue> = ResolveLazy<ClassValue> extends infer Resolved ? Resolved extends ClassAuthoring ? CorePropertyInputFromEntries<EffectivePropertyEntries<Resolved>> : Resolved extends language.ResolvedClass ? language.PropertyInputOf<Resolved> : never : never;
+export type CorePropertyInput<ClassValue> = ResolveLazy<ClassValue> extends infer Resolved ? Resolved extends Class ? CorePropertyInputFromEntries<EffectivePropertyEntries<Resolved>> : Resolved extends language.ResolvedClass ? language.PropertyInputOf<Resolved> : never : never;
 type PropertyEntryName<Entry> = Entry extends {
     readonly name: infer Name extends string;
 } ? Name : never;
@@ -186,26 +197,26 @@ type PropertyByName<Origin extends string, Entries, Root extends DomainSchemaInp
 type PropertyCollectionOperation = 'byKey' | 'get' | 'from';
 type PropertyCollectionOf<Origin extends string, Entries, Root extends DomainSchemaInput> = language.ResolvedPropertyCollection<PropertyByKey<Origin, Entries, Root>, PropertyByName<Origin, Entries, Root>>;
 type MethodFieldsOf<Value> = RecordField<ClassInputOf<Value>, 'methods'>;
-interface AuthoredMethodEntry<Owner, Name extends string, Value extends MethodAuthoring> {
+interface AuthoredMethodEntry<Owner, Name extends string, Value extends Method> {
     readonly owner: Owner;
     readonly name: Name;
     readonly value: Value;
 }
 type OwnMethodEntries<Value, Static extends boolean> = {
-    [Name in keyof MethodFieldsOf<Value>]: MethodFieldsOf<Value>[Name] extends infer MethodValue extends MethodAuthoring ? CallableConfig<MethodValue> extends {
+    [Name in keyof MethodFieldsOf<Value>]: MethodFieldsOf<Value>[Name] extends infer MethodValue extends Method ? CallableConfig<MethodValue> extends {
         readonly static: true;
     } ? Static extends true ? AuthoredMethodEntry<Value, Extract<Name, string>, MethodValue> : never : Static extends false ? AuthoredMethodEntry<Value, Extract<Name, string>, MethodValue> : never : never;
 }[keyof MethodFieldsOf<Value>];
-type ParentMethodEntries<Parent, Static extends boolean, Seen> = Parent extends language.ResolvedClass<'node'> ? Static extends true ? language.StaticMethodsOf<Parent>['byKey'][keyof language.StaticMethodsOf<Parent>['byKey']] : language.MethodsOf<Parent>['byKey'][keyof language.MethodsOf<Parent>['byKey']] : Parent extends NodeClassAuthoring ? EffectiveMethodEntries<Parent, Static, Seen> : never;
+type ParentMethodEntries<Parent, Static extends boolean, Seen> = Parent extends language.ResolvedClass<'node'> ? Static extends true ? language.StaticMethodsOf<Parent>['byKey'][keyof language.StaticMethodsOf<Parent>['byKey']] : language.MethodsOf<Parent>['byKey'][keyof language.MethodsOf<Parent>['byKey']] : Parent extends NodeClass ? EffectiveMethodEntries<Parent, Static, Seen> : never;
 type RemoveMethodNames<Entries, Names> = Entries extends {
     readonly name: infer Name;
 } ? Name extends Names ? never : Entries : never;
 type EffectiveMethodEntries<Value, Static extends boolean, Seen = never> = Value extends Seen ? never : OwnMethodEntries<Value, Static> extends infer Own ? Own | RemoveMethodNames<ParentsOf<Value> extends infer Parent ? Parent extends unknown ? ParentMethodEntries<Parent, Static, Seen | Value> : never : never, Own extends {
     readonly name: infer Name;
 } ? Name : never> : never;
-type CallableConfig<Value> = Value extends MethodAuthoring<infer Config> ? Config : Value extends FunctionAuthoring<infer Config> ? Config : never;
-type CallableInputValue<Value extends MethodAuthoring | FunctionAuthoring> = ValueInputOf<CallableConfig<Value>['input']>;
-type CallableOutputValue<Value extends MethodAuthoring | FunctionAuthoring> = CallableConfig<Value>['output'] extends StreamOutput<infer Item> ? {
+type CallableConfig<Value> = Value extends Method<infer Config> ? Config : Value extends Function<infer Config> ? Config : never;
+type CallableInputValue<Value extends Method | Function> = ValueInputOf<CallableConfig<Value>['input']>;
+type CallableOutputValue<Value extends Method | Function> = CallableConfig<Value>['output'] extends StreamOutput<infer Item> ? {
     readonly mode: 'stream';
     readonly item: ValueOutputOf<Item>;
 } : CallableConfig<Value>['output'] extends BinaryOutput ? {
@@ -217,14 +228,14 @@ type CallableOutputValue<Value extends MethodAuthoring | FunctionAuthoring> = Ca
 type ProjectedMethod<Origin extends string, Entry, Root extends DomainSchemaInput> = Entry extends language.ResolvedMethod ? Entry : Entry extends AuthoredMethodEntry<infer Owner, infer Name, infer Value> ? LocalNameOf<Root, Owner> extends infer OwnerName extends string ? language.ResolvedMethod<CallableInputValue<Value>, CallableOutputValue<Value>, CallableStaticOf<Value>, CallableInheritanceOf<Value>, CallableAuthOf<Value>, CallablePolicyOf<Value>, language.MethodKey<Origin, OwnerName, Name>> & {
     readonly name: Name;
 } : never : never;
-type CallableStaticOf<Value extends MethodAuthoring> = CallableConfig<Value> extends {
+type CallableStaticOf<Value extends Method> = CallableConfig<Value> extends {
     readonly static: true;
 } ? true : false;
-type CallableInheritanceOf<Value extends MethodAuthoring> = CallableConfig<Value> extends {
+type CallableInheritanceOf<Value extends Method> = CallableConfig<Value> extends {
     readonly inheritance: infer Inheritance extends language.MethodInheritance;
 } ? Inheritance : 'default';
-type CallableAuthOf<Value extends MethodAuthoring | FunctionAuthoring> = CallableConfig<Value>['auth'];
-type CallablePolicyOf<Value extends MethodAuthoring | FunctionAuthoring> = CallableAuthOf<Value> extends 'authorized' ? language.PolicyCheckExpression : never;
+type CallableAuthOf<Value extends Method | Function> = CallableConfig<Value>['auth'];
+type CallablePolicyOf<Value extends Method | Function> = CallableAuthOf<Value> extends 'authorized' ? language.PolicyCheckExpression : never;
 type ProjectedMethodUnion<Origin extends string, Entries, Root extends DomainSchemaInput> = Entries extends unknown ? ProjectedMethod<Origin, Entries, Root> : never;
 type MethodByKey<Origin extends string, Entries, Root extends DomainSchemaInput> = Readonly<{
     [Key in ProjectedMethodUnion<Origin, Entries, Root>['key']]: Extract<ProjectedMethodUnion<Origin, Entries, Root>, {
@@ -238,11 +249,10 @@ type MethodByName<Origin extends string, Entries, Root extends DomainSchemaInput
 }>;
 type MethodCollectionOperation = 'byKey' | 'get';
 type MethodCollectionOf<Origin extends string, Entries, Root extends DomainSchemaInput> = language.ResolvedMethodCollection<MethodByKey<Origin, Entries, Root>, MethodByName<Origin, Entries, Root>>;
-type ResolvedFunctionOfAuthoring<Origin extends string, Name extends string, Value> = Value extends FunctionAuthoring ? language.ResolvedFunction<CallableInputValue<Value>, CallableOutputValue<Value>, CallableAuthOf<Value>, CallablePolicyOf<Value>> & {
+type ResolvedFunctionOfAuthoring<Origin extends string, Name extends string, Value> = Value extends Function ? language.ResolvedFunction<CallableInputValue<Value>, CallableOutputValue<Value>, CallableAuthOf<Value>, CallablePolicyOf<Value>> & {
     readonly ref: language.FunctionRef<Name> & {
         readonly origin: Origin;
     };
     readonly key: language.DefinitionKey<Origin, 'function', Name>;
 } : never;
 export {};
-//# sourceMappingURL=projection.d.ts.map

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

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=projection.js.map