@astrale-os/kernel-dsl 1.0.0-beta.1 → 1.0.0-beta.10

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

@@ -1,7 +1,7 @@
 import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
 import type { z } from 'zod';
 import type { PolicyRef } from '../../addressing/index.js';
-import type { BinaryInputProjection, CallableExecution, FunctionAuth } from '../../language/callable/model/callable.js';
+import type { BinaryInputProjection, CallableAdmission, CallableExecution, FunctionAuth } from '../../language/callable/model/callable.js';
 import type { PolicyCheckExpression, PolicyCheckObject, PolicyObjectRef } from '../../language/policy/model/policy.js';
 import type { Class } from '../class/authoring.js';
 import type { ValueSchemaInput } from '../class/property.js';
@@ -62,6 +62,8 @@ export interface CallableInputBase<Input extends FunctionInputSchema = ValueSche
     readonly output: CallableOutputInput;
     /** `{ durable: true }` makes an invocation return an Execution reference. */
     readonly execution?: CallableExecution;
+    /** `{ maxAge }`: how old, in seconds, the admission a call is served under may be. */
+    readonly admission?: CallableAdmission;
 }
 type ConcreteCallableInput<Input extends FunctionInputSchema = ValueSchemaInput> = CallableInputBase<Input> & ({
     readonly auth: 'anonymous';
@@ -83,7 +85,7 @@ export type MethodInput = ConcreteCallableInput & {
     readonly abstract?: boolean;
 };
 export type CallableInput = FunctionInput | MethodInput;
-export interface CallableProjection<out Input = unknown, out Output = unknown, out Auth extends FunctionAuth = FunctionAuth, out Static extends boolean = boolean, out Abstract extends boolean = boolean, out Execution extends CallableExecution | undefined = CallableExecution | undefined> {
+export interface CallableProjection<out Input = unknown, out Output = unknown, out Auth extends FunctionAuth = FunctionAuth, out Static extends boolean = boolean, out Abstract extends boolean = boolean, out Execution extends CallableExecution | undefined = CallableExecution | undefined, out Admission extends CallableAdmission | undefined = CallableAdmission | undefined> {
     readonly [CALLABLE_PROJECTION_VALUE]: true;
     readonly input: Input;
     readonly output: Output;
@@ -91,6 +93,7 @@ export interface CallableProjection<out Input = unknown, out Output = unknown, o
     readonly static: Static;
     readonly abstract: Abstract;
     readonly execution: Execution;
+    readonly admission: Admission;
 }
 type ValueInputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : PortableValue;
 type FunctionInputOf<Schema> = Schema extends BinaryInputAuthoring<infer Metadata> ? BinaryInputProjection<ValueInputOf<Metadata>> : ValueInputOf<Schema>;
@@ -98,6 +101,9 @@ type ValueOutputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Valu
 type ExecutionOfConfig<Config extends CallableInput> = Config extends {
     readonly execution: infer Execution extends CallableExecution;
 } ? Execution : undefined;
+type AdmissionOfConfig<Config extends CallableInput> = Config extends {
+    readonly admission: infer Admission extends CallableAdmission;
+} ? Admission : undefined;
 type CallableOutputOf<Input extends CallableOutputInput> = Input extends StreamOutput<infer Item> ? {
     readonly mode: 'stream';
     readonly item: ValueOutputOf<Item>;
@@ -120,12 +126,12 @@ export type ProjectionOfCallable<Value extends Function | Method> = Value extend
 export declare function callableConfiguration(value: Function | Method): CallableInput;
 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 func<const Config extends FunctionInput, Input = FunctionInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth'], Execution extends CallableExecution | undefined = ExecutionOfConfig<Config>, Admission extends CallableAdmission | undefined = AdmissionOfConfig<Config>>(config: Config): Function<CallableProjection<Input, Output, Auth, false, false, Execution, Admission>>;
 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 {
     readonly static: true;
 } ? true : false, Abstract extends boolean = Config extends {
     readonly abstract: infer Value extends boolean;
-} ? Value : false, Execution extends CallableExecution | undefined = ExecutionOfConfig<Config>>(config: Config): Method<CallableProjection<Input, Output, Auth, Static, Abstract, Execution>>;
+} ? Value : false, Execution extends CallableExecution | undefined = ExecutionOfConfig<Config>, Admission extends CallableAdmission | undefined = AdmissionOfConfig<Config>>(config: Config): Method<CallableProjection<Input, Output, Auth, Static, Abstract, Execution, Admission>>;
 export declare function callableInputField(name: string): Extract<PolicyCheckObject, {
     readonly kind: 'input';
 }>;

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

@@ -18,6 +18,7 @@ export function func(config) {
         'static',
         'abstract',
         'execution',
+        'admission',
     ]);
     const value = authoringValue('function', {});
     callableInputs.set(value, { ...config });
@@ -33,6 +34,7 @@ export function method(config) {
         'static',
         'abstract',
         'execution',
+        'admission',
     ]);
     const value = authoringValue('method', {});
     callableInputs.set(value, { ...config });

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

@@ -3,8 +3,9 @@ import type { z } from 'zod';
 import type { ClassRef } from '../../addressing/index.js';
 import type { MethodRecord } from '../../language/callable/model/callable.js';
 import type { ResolvedMethod } from '../../language/callable/resolved.js';
+import type { Inheritance } from '../../language/class/model/class.js';
 import type { MediaType } from '../../language/class/model/data.js';
-import type { EdgeCount } from '../../language/class/model/edge.js';
+import type { EdgeCount, EdgeLifetime } from '../../language/class/model/edge.js';
 import type { ResolvedClass, ResolvedProperty } from '../../language/class/resolved.js';
 import type { ClassRuleChecks, ClassRuleObject } from '../../language/policy/model/policy.js';
 import type { StateTopology, StateTopologyOf } from '../../language/state/topology.js';
@@ -25,16 +26,22 @@ export interface DirectedSourceInput {
     readonly as: string;
     readonly accepts: readonly NodeClassReferenceInput[];
     readonly outgoing: EdgeCount;
+    /** What deleting a Node at this endpoint does to the Edge; derived when omitted. */
+    readonly onDelete?: EdgeLifetime;
 }
 export interface DirectedTargetInput {
     readonly as: string;
     readonly accepts: readonly NodeClassReferenceInput[];
     readonly incoming: EdgeCount;
+    /** What deleting a Node at this endpoint does to the Edge; derived when omitted. */
+    readonly onDelete?: EdgeLifetime;
 }
 export interface IncidentEndpointInput {
     readonly as: string;
     readonly accepts: readonly NodeClassReferenceInput[];
     readonly incident: EdgeCount;
+    /** What deleting a Node at this endpoint does to the Edge; derived when omitted. */
+    readonly onDelete?: EdgeLifetime;
 }
 type ExactEndpointInput<Input, Shape> = Input & Record<Exclude<keyof Input, keyof Shape>, never>;
 /** One observation slot: a local Policy, or its constant value. Absent means `true`. */
@@ -58,6 +65,8 @@ export interface NodeClassPoliciesInput {
 }
 export interface NodeClassInput {
     readonly abstract?: boolean;
+    /** Which Classes may extend this one; omitted, those of its own Domain only (`'internal'`). */
+    readonly inheritance?: Inheritance;
     readonly description?: string;
     readonly extends?: readonly NodeClassReferenceInput[];
     readonly properties?: PropertyRecordInput;
@@ -66,9 +75,21 @@ export interface NodeClassInput {
     readonly icon?: string;
     /** Local observation Policies; inherited by no descendant and forbidden on abstract Classes. */
     readonly policies?: NodeClassPoliciesInput;
+    /**
+     * The tuples no two Nodes of this Class and of its active concrete descendants share while every
+     * Property is present; omitted, none. A descendant is covered without declaring them again.
+     */
+    readonly unique?: readonly NodeUniqueTupleInput[];
 }
+/**
+ * The distinct Properties of one Node key, in any order, each a Property of the Class, own or
+ * inherited, by its name or, when names collide, by its full key.
+ */
+export type NodeUniqueTupleInput = readonly [string, ...string[]];
 export interface EdgeClassOptions {
     readonly abstract?: boolean;
+    /** Which Classes may extend this one; omitted, those of its own Domain only (`'internal'`). */
+    readonly inheritance?: Inheritance;
     readonly description?: string;
     readonly extends?: readonly EdgeClassReferenceInput[];
     readonly properties?: PropertyRecordInput;
@@ -79,10 +100,24 @@ export interface EdgeClassOptions {
         readonly acyclic?: true;
     };
 }
+/**
+ * A key field as authored: an endpoint, the slug, or a Property of the Class, own or inherited, by
+ * its name or, when names collide, by its full key.
+ */
+export type EdgeUniqueFieldInput = 'source' | 'target' | 'slug' | {
+    readonly property: string;
+};
+/** The distinct fields of one key, in any order. */
+export type EdgeUniqueTupleInput = readonly [EdgeUniqueFieldInput, ...EdgeUniqueFieldInput[]];
 export interface DirectedEdgeInput extends EdgeClassOptions {
     readonly orientation: 'directed';
     readonly source: DirectedSourceInput;
     readonly target: DirectedTargetInput;
+    /**
+     * The tuples no two Edges of this Class and of its active concrete descendants share while every
+     * field is present; omitted, none. A descendant is covered without declaring them again.
+     */
+    readonly unique?: readonly EdgeUniqueTupleInput[];
 }
 export interface UndirectedEdgeInput extends Omit<EdgeClassOptions, 'constraints'> {
     readonly orientation: 'undirected';

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

@@ -17,6 +17,7 @@ export function nodeClass(config) {
     const admitted = config ?? {};
     assertKnownKeys(admitted, [
         'abstract',
+        'inheritance',
         'description',
         'extends',
         'properties',
@@ -24,13 +25,21 @@ export function nodeClass(config) {
         'methods',
         'icon',
         'policies',
+        'unique',
     ]);
     if (admitted.policies !== undefined)
         assertKnownKeys(admitted.policies, ['read', 'traverse']);
     const value = authoringValue('definition', {
         kind: 'node',
     });
-    classInputs.set(value, { ...admitted, abstract: admitted.abstract ?? false });
+    classInputs.set(value, {
+        ...admitted,
+        // Copied, so the declaration does not follow later changes to the author's arrays.
+        ...(admitted.unique === undefined
+            ? {}
+            : { unique: admitted.unique.map((tuple) => [...tuple]) }),
+        abstract: admitted.abstract ?? false,
+    });
     return value;
 }
 export const edgeClass = Object.freeze({
@@ -39,15 +48,17 @@ export const edgeClass = Object.freeze({
             'source',
             'target',
             'abstract',
+            'inheritance',
             'description',
             'extends',
             'properties',
             'policies',
             'constraints',
+            'unique',
         ]);
         validateDirectedSourceInput(input.source);
         validateDirectedTargetInput(input.target);
-        const { source, target, ...options } = input;
+        const { source, target, unique, ...options } = input;
         validateEdgeClassOptions(options);
         const value = authoringValue('definition', {
             kind: 'edge',
@@ -56,6 +67,12 @@ export const edgeClass = Object.freeze({
         classInputs.set(value, {
             source: { ...source },
             target: { ...target },
+            // Copied, so the declaration does not follow later changes to the author's arrays.
+            ...(unique === undefined
+                ? {}
+                : {
+                    unique: unique.map((tuple) => tuple.map((field) => typeof field === 'string' ? field : { property: field.property })),
+                }),
             ...options,
             abstract: options.abstract ?? false,
         });
@@ -65,6 +82,7 @@ export const edgeClass = Object.freeze({
         assertKnownKeys(input, [
             'endpoints',
             'abstract',
+            'inheritance',
             'description',
             'extends',
             'properties',
@@ -96,17 +114,18 @@ export function classConfiguration(value) {
     return input;
 }
 function validateDirectedSourceInput(value) {
-    assertKnownKeys(value, ['as', 'accepts', 'outgoing']);
+    assertKnownKeys(value, ['as', 'accepts', 'outgoing', 'onDelete']);
 }
 function validateDirectedTargetInput(value) {
-    assertKnownKeys(value, ['as', 'accepts', 'incoming']);
+    assertKnownKeys(value, ['as', 'accepts', 'incoming', 'onDelete']);
 }
 function validateIncidentEndpointInput(value) {
-    assertKnownKeys(value, ['as', 'accepts', 'incident']);
+    assertKnownKeys(value, ['as', 'accepts', 'incident', 'onDelete']);
 }
 function validateEdgeClassOptions(value) {
     assertKnownKeys(value, [
         'abstract',
+        'inheritance',
         'description',
         'extends',
         'properties',
@@ -121,6 +140,7 @@ function validateEdgeClassOptions(value) {
 function validateUndirectedEdgeClassOptions(value) {
     assertKnownKeys(value, [
         'abstract',
+        'inheritance',
         'description',
         'extends',
         'properties',

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

@@ -14,7 +14,7 @@ export { BuilderError as Error } from './schema/diagnostic.js';
 export type { BuilderDiagnostic as Diagnostic, BuilderDiagnosticCode as DiagnosticCode, } from './schema/diagnostic.js';
 export type { CallableInputBase, CallableInput, BinaryInputAuthoring, CallableOutputInput, CallableProjection, CallablePolicyBuilder, CallablePolicyContext, PolicyCheckContext, BinaryOutput, Function, FunctionInput, Method, MethodInput, PolicyObjectInput, StreamOutput, } from './callable/authoring.js';
 export type { CoreEdge, CoreEndpoint, CoreInput, CoreNode } from './core/authoring.js';
-export type { AuthoredPropertyProjection, AuthoredMethodProjection, Class, ClassIdentityProjection, ClassOwnerProjection, ClassReferenceProjection, ClassReferenceInput as ClassReference, ClassRuleBuilder, ClassRuleContext, DirectedEdgeInput, DirectedEdgeClass, DirectedSourceInput, DirectedTargetInput, EdgeClassCommon, EdgeClassInput, EdgeClass, EdgeClassReferenceInput as EdgeClassReference, IncidentEndpointInput, NodeClass, NodeClassInput, NodeClassPoliciesInput, NodeClassPolicyInput, NodeClassReferenceInput as NodeClassReference, UndirectedEdgeInput, UndirectedEdgeClass, } from './class/authoring.js';
+export type { AuthoredPropertyProjection, AuthoredMethodProjection, Class, ClassIdentityProjection, ClassOwnerProjection, ClassReferenceProjection, ClassReferenceInput as ClassReference, ClassRuleBuilder, ClassRuleContext, DirectedEdgeInput, DirectedEdgeClass, DirectedSourceInput, DirectedTargetInput, EdgeClassCommon, EdgeClassInput, EdgeClass, EdgeClassReferenceInput as EdgeClassReference, EdgeUniqueFieldInput, EdgeUniqueTupleInput, IncidentEndpointInput, NodeClass, NodeClassInput, NodeClassPoliciesInput, NodeClassPolicyInput, NodeClassReferenceInput as NodeClassReference, NodeUniqueTupleInput, UndirectedEdgeInput, UndirectedEdgeClass, } from './class/authoring.js';
 export type { PathAuthoring } from './value/path.js';
 export type { Lazy } from './schema/lazy.js';
 export type { MatchPolicyInput, Policy, PolicyBuilder as PolicyFactory, PolicyEdgeInput, PolicyExistsContext, PolicyInput, PolicyNodeBinder, PolicyPatternContext, } from './policy/authoring.js';

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

@@ -42,6 +42,7 @@ export class V1CallableCompiler {
             input,
             output,
             ...(config.execution === undefined ? {} : { execution: config.execution }),
+            ...(config.admission === undefined ? {} : { admission: config.admission }),
         };
         const contract = auth === 'authorized'
             ? { ...base, auth, ...(policy === undefined ? {} : { policy }) }

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

@@ -31,6 +31,7 @@ export class V1DefinitionCompiler {
             ref: { origin: this.context.origin, kind: 'class', name },
             kind: 'node',
             abstract: input.abstract ?? false,
+            ...declaredInheritance(input.inheritance),
             ...(input.description === undefined ? {} : { description: input.description }),
             extends: this.parents(input.extends, 'node', `${pointer}/extends`),
             properties: facet,
@@ -38,6 +39,11 @@ export class V1DefinitionCompiler {
             ...(data === undefined ? {} : { data }),
             ...(input.icon === undefined ? {} : { icon: input.icon }),
             policies: this.classPolicies(input, 'node', `${pointer}/policies`),
+            // Property names stay as authored until `canonicalizeUniquePropertyKeys` qualifies them
+            // against the Class's effective Properties, once every Class is lowered.
+            ...(input.unique === undefined
+                ? {}
+                : { unique: input.unique }),
         };
     }
     edgeClass(value, name, pointer) {
@@ -53,6 +59,11 @@ export class V1DefinitionCompiler {
                         target: this.directedTarget(directed.target, `${pointer}/endpoints/target`),
                     },
                     constraints: directedConstraints(directed),
+                    // Property names stay as authored until `canonicalizeUniquePropertyKeys` qualifies them
+                    // against the Class's effective Properties, once every Class is lowered.
+                    ...(directed.unique === undefined
+                        ? {}
+                        : { unique: directed.unique }),
                 };
             }
             const undirected = classConfiguration(value);
@@ -69,6 +80,7 @@ export class V1DefinitionCompiler {
             ref: { origin: this.context.origin, kind: 'class', name },
             kind: 'edge',
             abstract: input.abstract ?? false,
+            ...declaredInheritance(input.inheritance),
             ...(input.description === undefined ? {} : { description: input.description }),
             extends: this.parents(input.extends, 'edge', `${pointer}/extends`),
             properties: facet,
@@ -126,6 +138,7 @@ export class V1DefinitionCompiler {
             accepts: value.accepts
                 .map((entry, index) => this.context.resolveNodeClass(entry, `${pointer}/accepts/${index}`))
                 .sort(compareDefinitionRefs),
+            ...(value.onDelete === undefined ? {} : { onDelete: value.onDelete }),
         };
     }
     directedSource(value, pointer) {
@@ -139,7 +152,7 @@ export class V1DefinitionCompiler {
     }
     parents(values, kind, pointer) {
         return (values ?? [])
-            .map((entry, index) => this.context.resolveClass(entry, kind, `${pointer}/${index}`))
+            .map((entry, index) => this.context.resolveParent(entry, kind, `${pointer}/${index}`))
             .sort(compareDefinitionRefs);
     }
     methods(values, abstractOwner, pointer) {
@@ -158,6 +171,10 @@ export class V1DefinitionCompiler {
         }));
     }
 }
+/** The default `'internal'` is never declared, so a Class that keeps it keeps its revision. */
+function declaredInheritance(inheritance) {
+    return inheritance === undefined || inheritance === 'internal' ? {} : { inheritance };
+}
 function dataDeclaration(mediaType) {
     return mediaType === undefined ? undefined : { mediaType };
 }

package/dist/v1/builder/lowering/property-keys.d.ts

@@ -0,0 +1,27 @@
+import type { ClassDefinition } from '../../language/class/model/class.js';
+import type { CoreContent } from '../../language/core/model/core.js';
+import type { DefinitionAnalysis } from '../../schema/analysis/class.js';
+import type { DomainSchemaLookup } from '../../schema/dependency/lookup.js';
+import type { DomainSchemaIR } from '../../schema/model/schema.js';
+import type { UnqualifiedCoreContent } from './core.js';
+type UnqualifiedDomainSchema = Omit<DomainSchemaIR, 'core'> & {
+    readonly core: UnqualifiedCoreContent;
+};
+/** The effective Properties of every Class `candidate` resolves, by `definitionRefIndex`. */
+export type PropertyOwners = ReadonlyMap<string, DefinitionAnalysis>;
+/**
+ * Analyze the already-canonical Definition surface of `candidate` once, so Property shorthand
+ * resolves against each Class's own and inherited Properties. Core values and key tuples take no
+ * part in Class composition, so they are left out of the analysis.
+ */
+export declare function analyzePropertyOwners(candidate: UnqualifiedDomainSchema, lookup: DomainSchemaLookup): PropertyOwners;
+/** Lower rich builder shorthand to the canonical full-key Core representation. */
+export declare function canonicalizeCorePropertyKeys(core: UnqualifiedCoreContent, owners: PropertyOwners): CoreContent;
+/**
+ * Lower each Property a key tuple names by its name to its full key among the Class's own and
+ * inherited Properties; a full key stays as authored. Ambiguity and absence are refused here, so a
+ * tuple never names a Property the author did not mean. A Node tuple names Properties only; an Edge
+ * tuple names them as `{ property }` beside its structural fields.
+ */
+export declare function canonicalizeUniquePropertyKeys(classes: Readonly<Record<string, ClassDefinition>>, origin: string, owners: PropertyOwners): Readonly<Record<string, ClassDefinition>>;
+export {};

package/dist/v1/builder/lowering/property-keys.js

@@ -0,0 +1,108 @@
+import { PropertyKey as admitPropertyKey } from '../../addressing/index.js';
+import { definitionRefIndex } from '../../addressing/ordering.js';
+import { createPropertyValues } from '../../language/class/property-values.js';
+import { analyzeDefinitions } from '../../schema/analysis/class.js';
+import { buildDomainResolutionContext } from '../../schema/resolution/context.js';
+import { escapeToken, fail } from '../schema/diagnostic.js';
+/**
+ * Analyze the already-canonical Definition surface of `candidate` once, so Property shorthand
+ * resolves against each Class's own and inherited Properties. Core values and key tuples take no
+ * part in Class composition, so they are left out of the analysis.
+ */
+export function analyzePropertyOwners(candidate, lookup) {
+    const analysisCandidate = {
+        ...candidate,
+        core: { nodes: {}, edges: [] },
+    };
+    return analyzeDefinitions(buildDomainResolutionContext(analysisCandidate, lookup)).definitions;
+}
+/** Lower rich builder shorthand to the canonical full-key Core representation. */
+export function canonicalizeCorePropertyKeys(core, owners) {
+    const nodes = Object.fromEntries(Object.entries(core.nodes).map(([slug, node]) => {
+        const definition = owners.get(definitionRefIndex(node.class));
+        if (definition === undefined) {
+            fail('BUILDER_CORE_PROPERTY', `/core/nodes/${escapeToken(slug)}/class`, 'Core property shorthand requires a resolvable concrete Class.');
+        }
+        return [
+            slug,
+            {
+                ...node,
+                properties: qualify(node.properties, definition, `/core/nodes/${escapeToken(slug)}/properties`),
+            },
+        ];
+    }));
+    const edges = core.edges.map((edge, index) => {
+        const definition = owners.get(definitionRefIndex(edge.class));
+        if (definition === undefined) {
+            fail('BUILDER_CORE_PROPERTY', `/core/edges/${index}/class`, 'Core property shorthand requires a resolvable concrete Class.');
+        }
+        return {
+            ...edge,
+            properties: qualify(edge.properties, definition, `/core/edges/${index}/properties`),
+        };
+    });
+    return { nodes, edges };
+}
+/**
+ * Lower each Property a key tuple names by its name to its full key among the Class's own and
+ * inherited Properties; a full key stays as authored. Ambiguity and absence are refused here, so a
+ * tuple never names a Property the author did not mean. A Node tuple names Properties only; an Edge
+ * tuple names them as `{ property }` beside its structural fields.
+ */
+export function canonicalizeUniquePropertyKeys(classes, origin, owners) {
+    return Object.fromEntries(Object.entries(classes).map(([name, declaration]) => {
+        if (declaration.kind === 'edge' && declaration.orientation !== 'directed') {
+            return [name, declaration];
+        }
+        if (declaration.unique === undefined)
+            return [name, declaration];
+        const ref = { origin, kind: 'class', name };
+        const definition = owners.get(definitionRefIndex(ref));
+        const pointer = `/classes/${escapeToken(name)}/unique`;
+        const resolve = (input, at) => {
+            if (definition === undefined) {
+                fail('BUILDER_UNIQUE_PROPERTY', at, 'A key Property requires a resolvable Class.');
+            }
+            return resolveInputKey(input, definition, 'BUILDER_UNIQUE_PROPERTY', at);
+        };
+        if (declaration.kind === 'node') {
+            const unique = declaration.unique.map((tuple, t) => tuple.map((key, f) => resolve(key, `${pointer}/${t}/${f}`)));
+            return [name, { ...declaration, unique }];
+        }
+        const unique = declaration.unique.map((tuple, t) => tuple.map((field, f) => typeof field === 'string'
+            ? field
+            : { property: resolve(field.property, `${pointer}/${t}/${f}/property`) }));
+        return [name, { ...declaration, unique }];
+    }));
+}
+function qualify(input, definition, pointer) {
+    const result = {};
+    const sourceByKey = new Map();
+    for (const [inputKey, value] of Object.entries(input)) {
+        const key = resolveInputKey(inputKey, definition, 'BUILDER_CORE_PROPERTY', `${pointer}/${escapeToken(inputKey)}`);
+        const previous = sourceByKey.get(key);
+        if (previous !== undefined) {
+            fail('BUILDER_CORE_PROPERTY', `${pointer}/${escapeToken(inputKey)}`, `Property is supplied twice through ${JSON.stringify(previous)} and ${JSON.stringify(inputKey)}.`);
+        }
+        sourceByKey.set(key, inputKey);
+        result[key] = value;
+    }
+    return createPropertyValues(Object.entries(result).map(([key, value]) => [admitPropertyKey(key), value]));
+}
+/** The full key of the Property `input` names on `definition`: its full key, or its unique name. */
+function resolveInputKey(input, definition, code, pointer) {
+    if (admitPropertyKey.is(input)) {
+        const key = admitPropertyKey(input);
+        if (!definition.properties.has(key)) {
+            fail(code, pointer, `Property ${input} is not present on the Class.`);
+        }
+        return key;
+    }
+    const candidates = [...definition.properties].flatMap(([key, field]) => field.name === input ? [key] : []);
+    if (candidates.length === 1)
+        return candidates[0];
+    if (candidates.length === 0) {
+        fail(code, pointer, `Property ${JSON.stringify(input)} does not exist.`);
+    }
+    fail(code, pointer, `Property ${JSON.stringify(input)} is ambiguous; use one of: ${candidates.join(', ')}.`);
+}

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

@@ -7,13 +7,14 @@ import { parseDomainSchemaStructure } from '../../../schema/validation/domain.st
 import { assertKnownKeys, escapeToken } from '../../schema/diagnostic.js';
 import { V1CallableCompiler } from '../callable.js';
 import { V1DefinitionCompiler } from '../class.js';
-import { canonicalizeCorePropertyKeys } from '../core-properties.js';
 import { compileCore } from '../core.js';
 import { assertPolicyCompositionAcyclic, V1PolicyCompiler } from '../policy.js';
+import { analyzePropertyOwners, canonicalizeCorePropertyKeys, canonicalizeUniquePropertyKeys, } from '../property-keys.js';
 import { BuilderValueSchemas } from '../value/compile.js';
 import { V1ViewCompiler } from '../view.js';
 import { captureSchema, commitSchemaOwnership } from './capture.js';
 import { BuilderContext } from './context.js';
+import { assertAuthoredLifetimes } from './lifetime.js';
 /**
  * Compile the V1 TypeScript builder graph through the same semantic acceptance
  * path used for untrusted decoded schemas.
@@ -21,9 +22,11 @@ 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 dependencies = lookupEntriesForDependencies(input.dependencies ?? {});
+    const lookup = new MemoryDomainSchemaLookup(dependencies);
     const candidate = assembleDomainSchema(origin, input, lookup);
     const accepted = acceptDomainSchema(candidate, lookup);
+    assertAuthoredLifetimes(accepted, dependencies);
     commitSchemaOwnership(input, origin);
     return accepted;
 }
@@ -75,9 +78,11 @@ function assembleDomainSchema(origin, input, lookup) {
         views,
         core,
     };
+    const owners = analyzePropertyOwners(semanticContent, lookup);
     const qualifiedContent = {
         ...semanticContent,
-        core: canonicalizeCorePropertyKeys(semanticContent, lookup),
+        classes: canonicalizeUniquePropertyKeys(classes, origin, owners),
+        core: canonicalizeCorePropertyKeys(core, owners),
     };
     context.noteDomainEndpointReferences(qualifiedContent);
     const candidate = {

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

@@ -29,6 +29,8 @@ export declare class BuilderContext {
     captureFunction(value: Function, ref: FunctionRef, pointer: string): void;
     captureView(value: View, ref: ViewRef, pointer: string): void;
     resolveClass(input: ClassReferenceInput, kind: ClassKind, pointer: string): ClassRef;
+    /** A parent of another Domain must be open to it in the dependency revision authored against. */
+    resolveParent(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;

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

@@ -1,6 +1,7 @@
 import { compareDefinitionRefs, compareUnicode, definitionRefIndex, } from '../../../addressing/ordering.js';
 import { DEPENDENCY_ALIAS_PATTERN } from '../../../addressing/patterns.js';
 import { isMethodExecutable } from '../../../language/callable/executable.js';
+import { admitsForeignSubclass, inheritanceOf } from '../../../language/class/inheritance.js';
 import { policyObjectKey, policyObjectOrigin } from '../../../language/index.js';
 import { graphNodePathSchema } from '../../../language/value/syntax/node-path/schema.js';
 import { revisionOfDomainSchema } from '../../../schema/canonical/revision.js';
@@ -90,6 +91,17 @@ export class BuilderContext {
         }
         return { ...ref };
     }
+    /** A parent of another Domain must be open to it in the dependency revision authored against. */
+    resolveParent(input, kind, pointer) {
+        const ref = this.resolveClass(input, kind, pointer);
+        if (ref.origin === this.origin)
+            return ref;
+        const parent = this.#dependencies.get(ref.origin).schema.classes[ref.name];
+        if (!admitsForeignSubclass(parent)) {
+            fail('BUILDER_CLASS_INHERITANCE', pointer, `Class ${ref.origin}:class.${ref.name} is ${inheritanceOf(parent)}: only an open Class admits a subclass of another Domain.`);
+        }
+        return ref;
+    }
     resolveNodeClass(input, pointer) {
         return this.resolveClass(input, 'node', pointer);
     }

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

@@ -0,0 +1,11 @@
+import type { DomainSchemaEntry } from '../../../schema/dependency/lookup.js';
+import type { DomainSchema } from '../../../schema/model/schema.js';
+/**
+ * Authoring refuses two Edge Classes that acceptance keeps, because a stored Schema must decode
+ * again with the lifetimes it derives (BUILDER-EDGE-LIFETIMES):
+ * - one with an endpoint that can hold a Node of another Domain while an endpoint requires an Edge.
+ *   It can neither restrict that Domain's deletions nor detach below the required count, so the
+ *   required endpoint must become optional;
+ * - one whose lifetimes differ from those of an Edge Class it extends, the root Edge aside.
+ */
+export declare function assertAuthoredLifetimes(schema: DomainSchema, dependencies: readonly DomainSchemaEntry[]): void;

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

@@ -0,0 +1,55 @@
+import { Key } from '../../../addressing/key.js';
+import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { isGraphRoot } from '../../../language/class/inheritance.js';
+import { contractEndpoints, edgeLifetimes, lifetimeScope, reachesAnotherDomain, requiredEndpoint, } from '../../../language/class/lifetime.js';
+import { BuilderError, diagnostic, escapeToken } from '../../schema/diagnostic.js';
+/**
+ * Authoring refuses two Edge Classes that acceptance keeps, because a stored Schema must decode
+ * again with the lifetimes it derives (BUILDER-EDGE-LIFETIMES):
+ * - one with an endpoint that can hold a Node of another Domain while an endpoint requires an Edge.
+ *   It can neither restrict that Domain's deletions nor detach below the required count, so the
+ *   required endpoint must become optional;
+ * - one whose lifetimes differ from those of an Edge Class it extends, the root Edge aside.
+ */
+export function assertAuthoredLifetimes(schema, dependencies) {
+    const classes = [
+        ...Object.values(schema.classes),
+        ...dependencies.flatMap((entry) => Object.values(entry.schema.classes)),
+    ];
+    const scope = lifetimeScope(classes);
+    const declarations = new Map(classes.map((declaration) => [definitionRefIndex(declaration.ref), declaration]));
+    const diagnostics = Object.entries(schema.classes).flatMap(([name, declaration]) => {
+        if (declaration.kind !== 'edge')
+            return [];
+        const pointer = `/classes/${escapeToken(name)}`;
+        const endpoints = contractEndpoints(declaration);
+        const keys = declaration.orientation === 'directed' ? ['source', 'target'] : ['0', '1'];
+        const counts = declaration.orientation === 'directed' ? ['outgoing', 'incoming'] : ['incident', 'incident'];
+        const found = [];
+        const required = requiredEndpoint(declaration);
+        const reaching = endpoints.find(({ endpoint }) => reachesAnotherDomain(schema.origin, endpoint, scope));
+        if (required !== undefined && reaching !== undefined)
+            found.push(diagnostic('BUILDER_EDGE_LIFETIME', `${pointer}/endpoints/${keys[required.index]}/${counts[required.index]}`, `${Key.of(declaration.ref)} endpoint ${reaching.endpoint.role} can hold Nodes of another ` +
+                `Domain, so it cannot restrict their deletion, and endpoint ${required.endpoint.role} ` +
+                `requires ${required.count} Edges, so it cannot detach: make ${required.endpoint.role} optional.`));
+        const lifetimes = edgeLifetimes(declaration, scope);
+        declaration.extends.forEach((ref, index) => {
+            const parent = declarations.get(definitionRefIndex(ref));
+            if (parent?.kind !== 'edge' || isGraphRoot(parent))
+                return;
+            const inherited = edgeLifetimes(parent, scope);
+            const same = (order) => order.every((at, position) => lifetimes[position] === inherited[at]);
+            if (same([0, 1]) || (declaration.orientation === 'undirected' && same([1, 0])))
+                return;
+            found.push(diagnostic('BUILDER_EDGE_LIFETIME', `${pointer}/extends/${index}`, `${Key.of(declaration.ref)} has lifetimes ${spell(endpoints, lifetimes)}, and ` +
+                `${Key.of(parent.ref)} it extends has ${spell(contractEndpoints(parent), inherited)}: ` +
+                `an Edge Class keeps the lifetimes of the Classes it extends.`));
+        });
+        return found;
+    });
+    if (diagnostics.length > 0)
+        throw new BuilderError(diagnostics);
+}
+function spell(endpoints, lifetimes) {
+    return `${endpoints[0].endpoint.role} ${lifetimes[0]} and ${endpoints[1].endpoint.role} ${lifetimes[1]}`;
+}