@astrale-os/kernel-dsl 0.2.0-beta.46 → 0.2.0-beta.48

package/dist/v1/addressing/patterns.d.ts

@@ -5,11 +5,6 @@ export declare const MEMBER_NAME_PATTERN: RegExp;
 export declare const DEPENDENCY_ALIAS_PATTERN: RegExp;
 export declare const CORE_SLUG_PATTERN: RegExp;
 export declare const DOMAIN_REVISION_PATTERN: RegExp;
-export declare const DOMAIN_REVISION_FULL_MATCH = "sha256:[0-9a-f]{64}";
-export declare const DOMAIN_ORIGIN_FULL_MATCH = "([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?";
-export declare const MEMBER_NAME_FULL_MATCH = "[A-Za-z][A-Za-z0-9_]*";
-export declare const DEPENDENCY_ALIAS_FULL_MATCH = "[a-z][A-Za-z0-9]*";
-export declare const PROPERTY_KEY_FULL_MATCH = "([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?:class\\.[A-Za-z][A-Za-z0-9_]*\\.property\\.[A-Za-z][A-Za-z0-9_]*";
 export declare const PROPERTY_KEY_PATTERN: RegExp;
 export declare const patterns: Readonly<{
     coreSlug: RegExp;

package/dist/v1/addressing/patterns.js

@@ -3,11 +3,11 @@ export const MEMBER_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/u;
 export const DEPENDENCY_ALIAS_PATTERN = /^[a-z][A-Za-z0-9]*$/u;
 export const CORE_SLUG_PATTERN = /^[a-z][a-z0-9-]{0,99}$/u;
 export const DOMAIN_REVISION_PATTERN = /^sha256:[0-9a-f]{64}$/u;
-export const DOMAIN_REVISION_FULL_MATCH = 'sha256:[0-9a-f]{64}';
-export const DOMAIN_ORIGIN_FULL_MATCH = '([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?';
-export const MEMBER_NAME_FULL_MATCH = '[A-Za-z][A-Za-z0-9_]*';
-export const DEPENDENCY_ALIAS_FULL_MATCH = '[a-z][A-Za-z0-9]*';
-export const PROPERTY_KEY_FULL_MATCH = '([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?:class\\.[A-Za-z][A-Za-z0-9_]*\\.property\\.[A-Za-z][A-Za-z0-9_]*';
+const DOMAIN_REVISION_FULL_MATCH = 'sha256:[0-9a-f]{64}';
+const DOMAIN_ORIGIN_FULL_MATCH = '([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?';
+const MEMBER_NAME_FULL_MATCH = '[A-Za-z][A-Za-z0-9_]*';
+const DEPENDENCY_ALIAS_FULL_MATCH = '[a-z][A-Za-z0-9]*';
+const PROPERTY_KEY_FULL_MATCH = '([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?:class\\.[A-Za-z][A-Za-z0-9_]*\\.property\\.[A-Za-z][A-Za-z0-9_]*';
 export const PROPERTY_KEY_PATTERN = new RegExp(`^(?:${PROPERTY_KEY_FULL_MATCH})$`, 'u');
 export const patterns = Object.freeze({
     coreSlug: CORE_SLUG_PATTERN,

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

@@ -109,7 +109,7 @@ export interface Method<out Projection = unknown> {
 export type ProjectionOfCallable<Value extends Function | Method> = Value extends Function<infer Projection> ? Projection : Value extends Method<infer Projection> ? Projection : never;
 /** Internal lowering access; Callable authoring handles expose no public configuration object. */
 export declare function callableConfiguration(value: Function | Method): CallableInput;
-export type PolicyObjectAuthoring = Class | Function | Method | Policy | View | CoreNode;
+type PolicyObjectAuthoring = Class | Function | Method | Policy | View | CoreNode;
 export type PolicyObjectInput = Lazy<PolicyObjectAuthoring | PolicyObjectRef>;
 export declare function func<const Config extends FunctionInput, Input = FunctionInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth'], Execution extends CallableExecution | undefined = ExecutionOfConfig<Config>>(config: Config): Function<CallableProjection<Input, Output, Auth, false, false, Execution>>;
 export declare function method<const Config extends MethodInput, Input = ValueInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth'], Static extends boolean = Config extends {

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

@@ -79,18 +79,6 @@ export interface UndirectedEdgeInput extends Omit<EdgeClassOptions, 'constraints
 }
 export type EdgeClassCommon = EdgeClassOptions;
 export type EdgeClassInput = DirectedEdgeInput | UndirectedEdgeInput;
-export type ClassInput = ({
-    readonly kind: 'node';
-    readonly abstract: boolean;
-} & NodeClassInput) | ({
-    readonly kind: 'edge';
-    readonly orientation: 'directed';
-    readonly abstract: boolean;
-} & Omit<DirectedEdgeInput, 'orientation'>) | ({
-    readonly kind: 'edge';
-    readonly orientation: 'undirected';
-    readonly abstract: boolean;
-} & Omit<UndirectedEdgeInput, 'orientation'>);
 export type Class = NodeClass | EdgeClass;
 export interface AuthoredPropertyProjection<out Input = unknown, out Output = unknown, out Required extends boolean = boolean, out Name extends string = string, out Owner = 'self', out State extends StateTopology | undefined = StateTopology | undefined> {
     readonly input: Input;

package/dist/v1/builder/class/property.d.ts

@@ -1,5 +1,5 @@
 import type { z } from 'zod';
-import type { AutoEvent, AutoSet } from '../../language/class/model/property.js';
+import type { AutoEvent, AutoSet, PropertyImmutability } from '../../language/class/model/property.js';
 import type { StateMachine } from '../../language/state/index.js';
 import type { JsonSchema } from '../../language/value/model/schema.js';
 import type { AUTHORING } from '../schema/handle.js';
@@ -9,6 +9,8 @@ export type ValueSchemaInput = z.ZodType | JsonSchema;
 export interface PropertyOptions {
     readonly required?: boolean;
     readonly description?: string;
+    /** `create` freezes the value at creation; `once` admits one write while absent. */
+    readonly immutable?: PropertyImmutability;
 }
 export interface AutoOptions {
     readonly on: AutoEvent | readonly AutoEvent[];
@@ -35,7 +37,7 @@ export interface AutoProperty<out PropertyValue extends Property = Property> {
         };
     };
 }
-export type PropertyAuthoringInput<Value extends Property> = Value extends Property<infer Schema, infer Options, infer Machine> ? {
+type PropertyAuthoringInput<Value extends Property> = Value extends Property<infer Schema, infer Options, infer Machine> ? {
     readonly schema: Schema;
     readonly options: Options;
     readonly machine?: Machine;

package/dist/v1/builder/class/property.js

@@ -10,7 +10,12 @@ export function autoPropertyAuthoringInput(value) {
 }
 export function property(schema, options) {
     const admitted = options ?? {};
-    assertKnownKeys(admitted, ['required', 'description']);
+    assertKnownKeys(admitted, ['required', 'description', 'immutable']);
+    if (admitted.immutable !== undefined &&
+        admitted.immutable !== 'create' &&
+        admitted.immutable !== 'once') {
+        fail('BUILDER_PROPERTY_IMMUTABLE_INVALID', '/immutable', 'immutable is create or once.');
+    }
     return authoringValue('property', {
         [PROPERTY_INPUT]: {
             schema,
@@ -34,6 +39,9 @@ export function auto(property, options) {
         fail('BUILDER_AUTO_NESTED', '', 'auto(...) cannot wrap another auto Property.');
     }
     assertKnownKeys(options, ['on', 'set']);
+    if (propertyAuthoringInput(property).options.immutable !== undefined) {
+        fail('BUILDER_AUTO_IMMUTABLE', '', 'An auto Property cannot be immutable.');
+    }
     const authored = Array.isArray(options.on) ? options.on : [options.on];
     if (authored.length === 0)
         fail('BUILDER_AUTO_EVENT_INVALID', '/on', 'auto(...) requires an event.');

package/dist/v1/builder/index.d.ts

@@ -21,6 +21,6 @@ export type { MatchPolicyInput, Policy, PolicyBuilder as PolicyFactory, PolicyEd
 export type { AutoOptions, AutoProperty, Property, PropertyFieldInput as PropertyField, PropertyOptions, ValueSchemaInput, } from './class/property.js';
 export type { CorePropertyInput } from './schema/projection.js';
 export type { ClassProjection, FunctionProjection, MethodProjection, PropertyProjection, } from './schema/projection.js';
-export type { DomainSchemaInput as SchemaInput } from './schema/input.js';
+export type { DomainSchemaInput as SchemaInput, EntrypointOf } from './schema/input.js';
 export type { TypedValueSchema } from './value/schema.js';
 export type { View, ViewInput } from './view/authoring.js';

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

@@ -3,7 +3,7 @@ import type { FunctionDefinition, MethodDefinition } from '../../language/callab
 import type { Function, Method } from '../callable/authoring.js';
 import type { BuilderContext } from './schema/context.js';
 import type { BuilderValueSchemas } from './value/compile.js';
-export type CallablePlacement = {
+type CallablePlacement = {
     readonly kind: 'function';
     readonly ref: FunctionRef;
     readonly pointer: string;
@@ -22,3 +22,4 @@ export declare class V1CallableCompiler implements CallableCompiler {
     private compileOutput;
     private policyContext;
 }
+export {};

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

@@ -4,12 +4,12 @@ import type { CoreEndpointRef } from '../../language/core/model/core.js';
 import type { CoreInput } from '../core/authoring.js';
 import type { BuilderContext } from './schema/context.js';
 export declare function captureCore(input: CoreInput | undefined, context: BuilderContext): void;
-export interface UnqualifiedCoreDefinition {
+interface UnqualifiedCoreDefinition {
     readonly ref: CoreRef;
     readonly class: ClassRef;
     readonly properties: JsonObject;
 }
-export interface UnqualifiedCoreEdge {
+interface UnqualifiedCoreEdge {
     readonly class: ClassRef;
     readonly source: CoreEndpointRef;
     readonly target: CoreEndpointRef;
@@ -20,3 +20,4 @@ export interface UnqualifiedCoreContent {
     readonly edges: readonly UnqualifiedCoreEdge[];
 }
 export declare function compileCore(input: CoreInput | undefined, context: BuilderContext): UnqualifiedCoreContent;
+export {};

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

@@ -29,7 +29,16 @@ export function compileSchema(origin, input) {
 }
 /** Structural assembly before whole-Domain semantic acceptance. */
 function assembleDomainSchema(origin, input, lookup) {
-    assertKnownKeys(input, ['dependencies', 'classes', 'functions', 'policies', 'views', 'core']);
+    assertKnownKeys(input, [
+        'name',
+        'entrypoint',
+        'dependencies',
+        'classes',
+        'functions',
+        'policies',
+        'views',
+        'core',
+    ]);
     if (input.core !== undefined)
         assertKnownKeys(input.core, ['nodes', 'edges'], '/core');
     const context = new BuilderContext(origin, input.dependencies ?? {});
@@ -47,12 +56,16 @@ function assembleDomainSchema(origin, input, lookup) {
     }));
     const policies = mapRecord(input.policies ?? {}, (value, name) => policyCompiler.compile(value, name, `/policies/${escapeToken(name)}`));
     assertPolicyCompositionAcyclic(policies, origin);
-    const views = mapRecord(input.views ?? {}, (value, name) => viewCompiler.compile(value, name, `/views/${escapeToken(name)}`));
+    const views = mapRecord(input.views ?? {}, (value, name) => viewCompiler.compile(value, name));
     const core = compileCore(input.core, context);
     const semanticContent = {
         format: 'astrale.dsl',
         version: 'v1',
         origin,
+        name: input.name,
+        ...(input.entrypoint === undefined
+            ? {}
+            : { entrypoint: { origin, kind: 'view', name: input.entrypoint } }),
         // Class/Property resolution needs every dependency already referenced by
         // authored Definitions. Core endpoint refs are added immediately below.
         dependencies: context.dependencies(),

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

@@ -37,6 +37,9 @@ export class BuilderValueSchemas {
                 schema: canonicalizeValueSchema(schema, 'property-facet', this.registry),
                 required: authoredInput?.options.required ?? isRequired(schemaInput),
                 ...(autoInput === undefined ? {} : { auto: autoInput.options }),
+                ...(authoredInput?.options.immutable === undefined
+                    ? {}
+                    : { immutable: authoredInput.options.immutable }),
                 ...(authoredInput?.options.description === undefined
                     ? {}
                     : { description: authoredInput.options.description }),

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

@@ -2,7 +2,7 @@ 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 = {
+type ZodValueSchemaConversion = {
     readonly ok: true;
     readonly schema: JsonSchema;
     readonly diagnostics: readonly [];
@@ -10,7 +10,7 @@ export type ZodValueSchemaConversion = {
     readonly ok: false;
     readonly diagnostics: readonly BuilderDiagnostic[];
 };
-export interface ZodValueSchemaConversionOptions {
+interface ZodValueSchemaConversionOptions {
     /** Undefined is representable only as absence at a containing object-property boundary. */
     readonly position?: 'value' | 'object-property';
     /** Builder-only lowering hook keyed by the original Zod schema identity. */
@@ -30,3 +30,4 @@ export interface ZodValueSchemaOverrideContext {
 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: ZodType): boolean;
+export {};

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

@@ -1,11 +1,12 @@
 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;
+interface ViewCompiler {
+    compile(value: View, name: string): ViewDefinition;
 }
 export declare class V1ViewCompiler implements ViewCompiler {
     readonly context: BuilderContext;
     constructor(context: BuilderContext);
-    compile(value: View, name: string, pointer: string): ViewDefinition;
+    compile(value: View, name: string): ViewDefinition;
 }
+export {};

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

@@ -1,27 +1,15 @@
-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) {
+    compile(value, name) {
         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),
-                },
+            target: { kind: 'domain' },
         };
     }
 }
-function isTargetList(input) {
-    return Array.isArray(input);
-}

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

@@ -1,11 +1,13 @@
 import type { Domain } from '../../domain/model/domain.js';
 import type { DomainSchema } from '../../schema/model/schema.js';
-import type { DomainSchemaInput } from './input.js';
+import type { DomainSchemaInput, EntrypointOf } 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 declare function defineSchema<const Origin extends string, const Input extends DomainSchemaInput>(origin: Origin, input: Input & {
+    readonly entrypoint?: EntrypointOf<Input>;
+}): DefinedSchema<Origin, ResolvedDomainOfInput<Origin, Input>>;
 export type { ResolvedDomainOfInput } from './projection.js';

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_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 type BuilderDiagnosticCode = LanguageDiagnosticCode | 'BUILDER_ABSTRACT_POLICY' | 'BUILDER_AMBIGUOUS_OWNERSHIP' | 'BUILDER_AUTO_EVENT_INVALID' | 'BUILDER_AUTO_IMMUTABLE' | '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_PROPERTY_IMMUTABLE_INVALID' | '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;

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

@@ -1,7 +1,8 @@
 export declare const AUTHORING: unique symbol;
-export type AuthoringKind = 'definition' | 'function' | 'method' | 'callable-input' | 'callable-output' | 'policy' | 'view' | 'core-node' | 'core-edge' | 'property' | 'auto';
+type AuthoringKind = 'definition' | 'function' | 'method' | 'callable-input' | '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;
+export {};

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

@@ -6,6 +6,10 @@ import type { Policy } from '../policy/authoring.js';
 import type { View } from '../view/authoring.js';
 /** Complete authoring input accepted by defineSchema. */
 export interface DomainSchemaInput {
+    /** Display name of the Domain, one trimmed line of 1 to 100 characters. */
+    readonly name: string;
+    /** Name of the one declared View this Domain opens by default. */
+    readonly entrypoint?: string;
     readonly dependencies?: Readonly<Record<string, DomainSchema<string>>>;
     readonly classes?: Readonly<Record<string, Class>>;
     readonly functions?: Readonly<Record<string, Function>>;
@@ -13,3 +17,7 @@ export interface DomainSchemaInput {
     readonly views?: Readonly<Record<string, View>>;
     readonly core?: CoreInput;
 }
+/** An entrypoint can only name one of the Views the same input declares. */
+export type EntrypointOf<Input extends DomainSchemaInput> = Input extends {
+    readonly views: infer Views;
+} ? Extract<keyof Views, string> : never;

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

@@ -0,0 +1,51 @@
+import type * as language from '../../../language/index.js';
+import type { Method, CallableProjection, Function } from '../../callable/authoring.js';
+import type { RecordField, ClassInputOf, AbstractOf } from './identity.js';
+import type { MethodProjection, FunctionProjection } from './model.js';
+type MethodExecutableOf<OwnerAbstract extends boolean, MethodAbstract extends boolean> = MethodAbstract extends false ? true : OwnerAbstract extends false ? true : false;
+type MethodFieldsOf<Value> = RecordField<ClassInputOf<Value>, 'methods'>;
+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 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 CallableConfig<Value> = Value extends Method<infer Config> ? Config extends CallableProjection ? Config : never : Value extends Function<infer Config> ? Config extends CallableProjection ? Config : never : never;
+type CallableInputValue<Value extends Method | Function> = CallableConfig<Value>['input'];
+type CallableOutputValue<Value extends Method | Function> = CallableConfig<Value>['output'];
+type CallableExecutionOf<Value extends Method | Function> = CallableConfig<Value>['execution'];
+type CallableStaticOf<Value extends Method> = CallableConfig<Value> extends {
+    readonly static: true;
+} ? true : false;
+type CallableAbstractOf<Value extends Method> = CallableConfig<Value> extends {
+    readonly abstract: infer Abstract extends boolean;
+} ? Abstract : false;
+type CallableAuthOf<Value extends Method | Function> = CallableConfig<Value>['auth'];
+type MethodProjectionOfEntry<Origin extends string, OwnerName extends string, Entry> = Entry extends language.ResolvedMethod ? MethodProjectionOfResolved<Entry> : Entry extends AuthoredMethodEntry<infer Owner, infer Name, infer Value> ? MethodProjection<CallableInputValue<Value>, CallableOutputValue<Value>, CallableStaticOf<Value>, CallableAbstractOf<Value>, CallableAuthOf<Value>, Name, language.MethodKey<Origin, OwnerName, Name>, MethodExecutableOf<AbstractOf<ClassInputOf<Owner>>, CallableAbstractOf<Value>>, CallableExecutionOf<Value>> : never;
+type MethodProjectionOfEntries<Origin extends string, OwnerName extends string, Entries> = Entries extends unknown ? MethodProjectionOfEntry<Origin, OwnerName, Entries> : never;
+type MethodProjectionOfResolved<Value> = Value extends language.ResolvedMethod<infer Input, infer Output, infer Static, infer Abstract, infer Auth, infer _Policy, infer Key> & {
+    readonly name: infer Name extends string;
+} ? MethodProjection<Input, Output, Static, Abstract, Auth, Name, Key, Value['executable'], Value['execution']> : never;
+/** Capture each Method through its qualified lookup key. */
+export type MethodsOfCollection<Value> = Value extends {
+    readonly byKey: infer ByKey extends Readonly<Record<language.MethodKey, language.ResolvedMethod>>;
+} ? MethodProjectionOfResolved<ByKey[keyof ByKey]> : never;
+/** Project the instance Methods declared directly by one Class. */
+export type OwnInstanceMethodProjectionsOf<Origin extends string, Name extends string, Value> = MethodProjectionOfEntries<Origin, Name, OwnMethodEntries<Value, false>>;
+/** Project the static Methods declared directly by one Class. */
+export type OwnStaticMethodProjectionsOf<Origin extends string, Name extends string, Value> = MethodProjectionOfEntries<Origin, Name, OwnMethodEntries<Value, true>>;
+/** Bind an authored Function to its exact Domain coordinates. */
+export type FunctionProjectionOfAuthoring<Origin extends string, Name extends string, Value> = Value extends Function ? FunctionProjection<CallableInputValue<Value>, CallableOutputValue<Value>, CallableAuthOf<Value>, language.FunctionRef<Name> & {
+    readonly origin: Origin;
+}, language.DefinitionKey<Origin, 'function', Name>, CallableExecutionOf<Value>> : never;
+/** Restore a resolved Function while preserving its execution modifier. */
+export type ResolvedFunctionOfProjection<Value extends FunctionProjection> = Value extends FunctionProjection<infer Input, infer Output, infer Auth, infer Ref, infer Key, infer Execution> ? language.ResolvedFunction<Input, Output, Auth, language.PolicyCheckExpression> & {
+    readonly ref: Ref;
+    readonly key: Key;
+    readonly execution: Execution;
+} : never;
+export {};

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

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

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

@@ -0,0 +1,89 @@
+import type * as language from '../../../language/index.js';
+import type { NodeClass, DirectedEdgeClass, UndirectedEdgeClass, ClassReferenceProjection, Class, ProjectionOfClass } from '../../class/authoring.js';
+import type { DomainSchemaInput } from '../input.js';
+import type { OwnInstanceMethodProjectionsOf, OwnStaticMethodProjectionsOf } from './callable.js';
+import type { AbstractOf, ConstraintsOf, ResolveLazy, LocalNameOfReference, ClassesInputOf, LocalNameOf } from './identity.js';
+import type { ClassProjection } from './model.js';
+import type { EffectivePropertyProjectionsOf, OwnPropertyProjectionsOf } from './property.js';
+import type { ClassProjectionOfResolved, ExactClass } from './resolved-class.js';
+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 DirectedEdgeClass<infer Input> ? Input extends {
+    readonly source: infer Source extends {
+        readonly as: string;
+        readonly outgoing: language.EdgeCount;
+    };
+    readonly target: infer Target extends {
+        readonly as: string;
+        readonly incoming: language.EdgeCount;
+    };
+} ? language.EdgeClassDefinition & {
+    readonly ref: language.ClassRef<Name> & {
+        readonly origin: Origin;
+    };
+    readonly kind: 'edge';
+    readonly abstract: AbstractOf<Input>;
+    readonly orientation: 'directed';
+    readonly endpoints: {
+        readonly source: language.DirectedSourceEndpoint & {
+            readonly role: Source['as'];
+            readonly outgoing: Source['outgoing'];
+        };
+        readonly target: language.DirectedTargetEndpoint & {
+            readonly role: Target['as'];
+            readonly incoming: Target['incoming'];
+        };
+    };
+    readonly constraints: language.DirectedEdgeConstraints & ConstraintsOf<Input>;
+} : never : Value extends UndirectedEdgeClass<infer Input> ? Input extends {
+    readonly endpoints: readonly [
+        infer First extends {
+            readonly as: string;
+            readonly incident: language.EdgeCount;
+        },
+        infer Second extends {
+            readonly as: string;
+            readonly incident: language.EdgeCount;
+        }
+    ];
+} ? language.EdgeClassDefinition & {
+    readonly ref: language.ClassRef<Name> & {
+        readonly origin: Origin;
+    };
+    readonly kind: 'edge';
+    readonly abstract: AbstractOf<Input>;
+    readonly orientation: 'undirected';
+    readonly endpoints: readonly [
+        language.IncidentEndpoint & {
+            readonly role: First['as'];
+            readonly incident: First['incident'];
+        },
+        language.IncidentEndpoint & {
+            readonly role: Second['as'];
+            readonly incident: Second['incident'];
+        }
+    ];
+    readonly constraints: language.UndirectedEdgeConstraints & ConstraintsOf<Input>;
+} : never : never;
+type ParentInputsOfConfig<Config> = Config extends {
+    readonly extends?: infer Parents extends readonly unknown[];
+} ? Parents : readonly [];
+type ParentClassProjectionOf<Origin extends string, Parent, Root extends DomainSchemaInput, Seen> = ResolveLazy<Parent> extends infer Resolved ? Resolved extends ClassReferenceProjection<infer _Kind, infer _Identity, infer _Properties, infer _InstanceMethods, infer _StaticMethods> ? LocalNameOfReference<Root, Resolved> extends infer Name extends string ? Name extends keyof ClassesInputOf<Root> ? ShallowClassProjectionOfAuthoring<Origin, Name, Extract<ClassesInputOf<Root>[Name], Class>, Root> : never : never : Resolved extends ClassProjection ? Resolved : Resolved extends language.AnyResolvedClass ? ClassProjectionOfResolved<ExactClass<Resolved>> : LocalNameOf<Root, Resolved> extends infer Name extends string ? Resolved extends Seen ? never : ClassProjectionOfAuthoring<Origin, Name, Resolved, Root, Seen | Resolved> : never : never;
+type ParentClassProjectionTuple<Origin extends string, Parents extends readonly unknown[], Root extends DomainSchemaInput, Seen> = Parents extends readonly [] ? readonly [] : Parents extends readonly [infer Parent, ...infer Rest] ? readonly [
+    ParentClassProjectionOf<Origin, Parent, Root, Seen>,
+    ...ParentClassProjectionTuple<Origin, Rest, Root, Seen>
+] : readonly ParentClassProjectionOf<Origin, Parents[number], Root, Seen>[];
+/** A shallow parent retains member contracts without expanding another parent tuple. */
+type ShallowClassProjectionOfAuthoring<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput> = ClassProjectionWithParents<Origin, Name, Value, Root, readonly language.AnyResolvedClass[]>;
+/** Project each authored Class independently before computing its parent tuple. */
+export type ClassProjectionOfAuthoring<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput, Seen = Value> = Value extends Class ? ClassProjectionWithParents<Origin, Name, Value, Root, ParentClassProjectionTuple<Origin, ParentInputsOfConfig<ProjectionOfClass<Extract<Value, Class>>>, Root, Seen>> : never;
+type ClassProjectionWithParents<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput, Parents extends readonly unknown[]> = Value extends NodeClass<infer _Config> ? ClassProjection<'node', Extract<ProjectedClassDefinition<Origin, Name, Value>, language.NodeClassDefinition>, language.ClassRef<Name> & {
+    readonly origin: Origin;
+}, language.DefinitionKey<Origin, 'class', Name>, Parents, EffectivePropertyProjectionsOf<Origin, Name, Value, Root>, OwnInstanceMethodProjectionsOf<Origin, Name, Value>, OwnStaticMethodProjectionsOf<Origin, Name, Value>, OwnPropertyProjectionsOf<Origin, Name, Value>, OwnInstanceMethodProjectionsOf<Origin, Name, Value>, OwnStaticMethodProjectionsOf<Origin, Name, Value>> : Value extends DirectedEdgeClass | UndirectedEdgeClass ? ClassProjection<'edge', Extract<ProjectedClassDefinition<Origin, Name, Value>, language.EdgeClassDefinition>, language.ClassRef<Name> & {
+    readonly origin: Origin;
+}, language.DefinitionKey<Origin, 'class', Name>, Parents, EffectivePropertyProjectionsOf<Origin, Name, Value, Root>, never, never, OwnPropertyProjectionsOf<Origin, Name, Value>, never, never> : never;
+export {};

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

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

package/dist/v1/builder/schema/projection/core-input.d.ts

@@ -0,0 +1,32 @@
+import type * as language from '../../../language/index.js';
+import type { BlobReceipt } from '../../../language/value/model/blob.js';
+import type { Class, AuthoredPropertyProjection } from '../../class/authoring.js';
+import type { ResolveLazy, IsMultiple } from './identity.js';
+import type { EffectivePropertyEntriesOfClass } from './property.js';
+/** Derive required, optional and forbidden Core Property inputs by name. */
+export type CoreNamedPropertyInput<ClassValue> = ResolveLazy<ClassValue> extends infer Resolved ? Resolved extends Class ? CorePropertyInputFromAuthoredProjections<EffectivePropertyEntriesOfClass<Resolved>> : Resolved extends language.ResolvedClass ? language.PropertyInputOf<Resolved> : never : never;
+/** Allow exact named Core inputs or canonical qualified Property keys. */
+export type CorePropertyInput<ClassValue> = CoreNamedPropertyInput<ClassValue> | Readonly<Record<language.PropertyKey, language.PropertyValue>>;
+type AuthoredProjectionName<Entry> = Entry extends AuthoredPropertyProjection<unknown, unknown, boolean, infer Name> ? Name : never;
+type AuthoredProjectionInput<Entry> = Entry extends AuthoredPropertyProjection<infer Input, unknown, boolean, string> ? Input : never;
+type CoreProjectionInput<Entry> = Entry extends AuthoredPropertyProjection<infer Input, infer Output, boolean, string> ? Input extends BlobReceipt ? Output : Input : never;
+type AuthoredProjectionRequired<Entry> = Entry extends AuthoredPropertyProjection<unknown, unknown, infer Required, string> ? Required : false;
+type UniqueAuthoredProjections<Entries> = Entries extends unknown ? IsMultiple<Extract<Entries, {
+    readonly name: AuthoredProjectionName<Entries>;
+}>> extends true ? never : Entries : never;
+type CoreAuthoredProjections<Entries> = UniqueAuthoredProjections<Entries> extends infer Entry ? Entry extends unknown ? [AuthoredProjectionInput<Entry>] extends [never] ? never : Entry : never : never;
+type RequiredAuthoredPropertyNames<Entries> = CoreAuthoredProjections<Entries> extends infer Entry ? Entry extends unknown ? AuthoredProjectionRequired<Entry> extends true ? AuthoredProjectionName<Entry> : never : never : never;
+type OptionalAuthoredPropertyNames<Entries> = Exclude<AuthoredProjectionName<CoreAuthoredProjections<Entries>>, RequiredAuthoredPropertyNames<Entries>>;
+type AutomaticAuthoredPropertyNames<Entries> = UniqueAuthoredProjections<Entries> extends infer Entry ? Entry extends unknown ? [AuthoredProjectionInput<Entry>] extends [never] ? AuthoredProjectionName<Entry> : never : never : never;
+type CorePropertyInputFromAuthoredProjections<Entries> = Readonly<{
+    [Name in RequiredAuthoredPropertyNames<Entries>]: CoreProjectionInput<Extract<CoreAuthoredProjections<Entries>, {
+        readonly name: Name;
+    }>>;
+} & {
+    [Name in OptionalAuthoredPropertyNames<Entries>]?: CoreProjectionInput<Extract<CoreAuthoredProjections<Entries>, {
+        readonly name: Name;
+    }>>;
+} & {
+    [Name in AutomaticAuthoredPropertyNames<Entries>]?: never;
+}>;
+export {};

package/dist/v1/builder/schema/projection/core-input.js

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

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

@@ -0,0 +1,59 @@
+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 { DomainSchema, DomainOfSchema } from '../../../schema/model/schema.js';
+import type { DomainSchemaInput } from '../input.js';
+import type { FunctionProjectionOfAuthoring, ResolvedFunctionOfProjection } from './callable.js';
+import type { ClassProjectionOfAuthoring } from './class.js';
+import type { ClassesInputOf, RecordField } from './identity.js';
+import type { DomainProjection, ClassProjection, FunctionProjection } from './model.js';
+import type { ResolvedClassOfProjection } from './resolved-class.js';
+type ProjectionOfInput<Origin extends string, Input extends DomainSchemaInput> = DomainProjection<{
+    readonly [Name in keyof ClassesInputOf<Input>]: ClassProjectionOfAuthoring<Origin, Extract<Name, string>, ClassesInputOf<Input>[Name], Input>;
+}, {
+    readonly [Name in keyof FunctionsInputOf<Input>]: FunctionProjectionOfAuthoring<Origin, Extract<Name, string>, FunctionsInputOf<Input>[Name]>;
+}, {
+    readonly [Name in keyof PoliciesInputOf<Input>]: language.ResolvedPolicy & {
+        readonly ref: language.PolicyRef<Extract<Name, string>> & {
+            readonly origin: Origin;
+        };
+        readonly key: language.DefinitionKey<Origin, 'policy', Extract<Name, string>>;
+    };
+}, {
+    readonly [Name in keyof ViewsInputOf<Input>]: language.ResolvedView & {
+        readonly ref: language.ViewRef<Extract<Name, string>> & {
+            readonly origin: Origin;
+        };
+        readonly key: language.DefinitionKey<Origin, 'view', Extract<Name, string>>;
+    };
+}, {
+    readonly [Name in keyof CoreNodesInputOf<Input>]: language.ResolvedCoreDefinition & {
+        readonly ref: language.CoreRef<Extract<Name, string>> & {
+            readonly origin: Origin;
+        };
+        readonly key: language.DefinitionKey<Origin, 'core', Extract<Name, string>>;
+    };
+}, DependencySchemasOf<Input>>;
+interface DomainOfProjection<Projection extends DomainProjection> extends domain.Domain<{
+    readonly [Name in keyof Projection['classes']]: ResolvedClassOfProjection<Extract<Projection['classes'][Name], ClassProjection>>;
+}, {
+    readonly [Name in keyof Projection['functions']]: ResolvedFunctionOfProjection<Extract<Projection['functions'][Name], FunctionProjection>>;
+}, Extract<Projection['policies'], Readonly<Record<string, language.ResolvedPolicy>>>, Extract<Projection['views'], Readonly<Record<string, language.ResolvedView>>>, Extract<Projection['core'], Readonly<Record<string, language.ResolvedCoreDefinition>>>, Revision> {
+    readonly dependencies: domain.DependencyDomainNamespace<{
+        readonly [Alias in keyof Projection['dependencies']]: Projection['dependencies'][Alias] extends infer Dependency extends DomainSchema ? DomainOfSchema<Dependency> : never;
+    }>;
+}
+/** Resolve compact authored witnesses into the exact public Domain type. */
+export type ResolvedDomainOfInput<Origin extends string, Input extends DomainSchemaInput> = DomainOfProjection<ProjectionOfInput<Origin, Input>>;
+type DependenciesInputOf<Input extends DomainSchemaInput> = RecordField<Input, 'dependencies'>;
+type DependencySchemasOf<Input extends DomainSchemaInput> = {
+    readonly [Alias in keyof DependenciesInputOf<Input>]: DependenciesInputOf<Input>[Alias];
+};
+type FunctionsInputOf<Input extends DomainSchemaInput> = RecordField<Input, 'functions'>;
+type PoliciesInputOf<Input extends DomainSchemaInput> = RecordField<Input, 'policies'>;
+type ViewsInputOf<Input extends DomainSchemaInput> = RecordField<Input, 'views'>;
+type CoreInputOf<Input extends DomainSchemaInput> = Input extends {
+    readonly core?: infer CoreValue;
+} ? NonNullable<CoreValue> : Record<never, never>;
+type CoreNodesInputOf<Input extends DomainSchemaInput> = RecordField<CoreInputOf<Input>, 'nodes'>;
+export {};

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

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