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

package/dist/v1/language/callable/resolved.d.ts

@@ -1,17 +1,17 @@
 import type { DefinitionKey, FunctionRef, Key, MethodKey } from '../../addressing/index.js';
 import type { ResolvedClass } from '../class/resolved.js';
-import type { PolicyCheckExpression } from '../policy/model/policy.js';
+import type { CallablePolicy } from '../policy/model/policy.js';
 import type { Diagnostic } from '../validation/diagnostic.js';
-import type { FunctionDefinition, MethodDefinition } from './model/callable.js';
+import type { BinaryInputProjection, CallableExecution, FunctionDefinition, MethodDefinition } from './model/callable.js';
 import type { FunctionAuth } from './model/callable.js';
-type CallableDefinitionOf<Definition extends FunctionDefinition | MethodDefinition, Auth extends FunctionAuth, Policy extends PolicyCheckExpression> = Omit<Definition, 'auth' | 'policy'> & (Auth extends FunctionAuth ? {
+type CallableDefinitionOf<Definition extends FunctionDefinition | MethodDefinition, Auth extends FunctionAuth, Policy extends CallablePolicy> = Omit<Definition, 'auth' | 'policy'> & (Auth extends FunctionAuth ? {
     readonly auth: Auth;
 } & (Auth extends 'authorized' ? {
     readonly policy?: Policy;
 } : {
     readonly policy?: never;
 }) : never);
-export interface ResolvedMethod<out Input = unknown, out Output = unknown, out Static extends boolean = boolean, out Inheritance extends MethodDefinition['inheritance'] = MethodDefinition['inheritance'], out Auth extends FunctionAuth = FunctionAuth, out Policy extends PolicyCheckExpression = PolicyCheckExpression, out ExactKey extends MethodKey = MethodKey> {
+export interface ResolvedMethod<out Input = unknown, out Output = unknown, out Static extends boolean = boolean, out Abstract extends MethodDefinition['abstract'] = MethodDefinition['abstract'], out Auth extends FunctionAuth = FunctionAuth, out Policy extends CallablePolicy = CallablePolicy, out ExactKey extends MethodKey = MethodKey> {
     readonly owner: ResolvedClass<'node'> & {
         readonly key: MethodOwnerKeyOfKey<ExactKey>;
     };
@@ -20,15 +20,19 @@ export interface ResolvedMethod<out Input = unknown, out Output = unknown, out S
     readonly description?: MethodDefinition['description'];
     readonly input: MethodDefinition['input'];
     readonly output: MethodDefinition['output'];
+    /** Present only for a durable Method. */
+    readonly execution?: CallableExecution;
     readonly auth: Auth;
     readonly policy?: Auth extends 'authorized' ? Policy : never;
     readonly static: Static;
-    readonly inheritance: Inheritance;
+    readonly abstract: Abstract;
+    /** Whether this exact local declaration requires an implementation. */
+    readonly executable: Abstract extends false ? true : boolean;
     /** Present only when the callable input is a safely enumerable closed object. */
     readonly inputFields?: readonly string[];
     readonly definition: CallableDefinitionOf<MethodDefinition, Auth, Policy> & {
         readonly static: Static;
-        readonly inheritance: Inheritance;
+        readonly abstract: Abstract;
     };
     validateInput(input: unknown): readonly Diagnostic[];
     validateInputField(field: string, input: unknown): readonly Diagnostic[];
@@ -41,12 +45,14 @@ export type ResolvedMethodCollection<ByKey extends Readonly<Record<MethodKey, Re
     get<Key extends keyof ByKey>(key: Key): ByKey[Key];
     get(key: MethodKey): ResolvedMethod | undefined;
 };
-export interface ResolvedFunction<out Input = unknown, out Output = unknown, out Auth extends FunctionAuth = FunctionAuth, out Policy extends PolicyCheckExpression = PolicyCheckExpression> {
+export interface ResolvedFunction<out Input = unknown, out Output = unknown, out Auth extends FunctionAuth = FunctionAuth, out Policy extends CallablePolicy = CallablePolicy> {
     readonly ref: FunctionRef;
     readonly key: DefinitionKey<string, 'function'>;
     readonly description?: FunctionDefinition['description'];
     readonly input: FunctionDefinition['input'];
     readonly output: FunctionDefinition['output'];
+    /** Present only for a durable Function. */
+    readonly execution?: CallableExecution;
     readonly auth: Auth;
     readonly policy?: Auth extends 'authorized' ? Policy : never;
     /** Present only when the callable input is a safely enumerable closed object. */
@@ -63,6 +69,15 @@ export type MethodOwnerKeyOf<Method> = Method extends {
     readonly key: infer ExactKey extends MethodKey;
 } ? MethodOwnerKeyOfKey<ExactKey> : never;
 type MethodOwnerKeyOfKey<ExactKey extends MethodKey> = ExactKey extends `${infer Origin}:class.${infer Owner}.method.${string}` ? DefinitionKey<Extract<Origin, Key.Origin>, 'class', Owner> : never;
-export type CallableInputOf<Callable> = Callable extends ResolvedMethod<infer Input, unknown, boolean> ? Input : Callable extends ResolvedFunction<infer Input, unknown> ? Input : never;
+type ProjectedCallableInputOf<Callable> = Callable extends ResolvedMethod<infer Input, unknown, boolean> ? Input : Callable extends ResolvedFunction<infer Input, unknown> ? Input : never;
+type InputValue<Input> = Input extends BinaryInputProjection<infer Metadata> ? Metadata : Input;
+/** Portable metadata for a binary Function, or the Value for an ordinary callable. */
+export type CallableInputOf<Callable> = InputValue<ProjectedCallableInputOf<Callable>>;
+type InputMode<Input> = Input extends BinaryInputProjection ? 'binary' : 'value';
+export type CallableInputModeOf<Callable> = InputMode<ProjectedCallableInputOf<Callable>>;
 export type CallableOutputOf<Callable> = Callable extends ResolvedMethod<unknown, infer Output, boolean> ? Output : Callable extends ResolvedFunction<unknown, infer Output> ? Output : never;
+/** An exact local Method whose Schema requires an implementation. */
+export type ExecutableMethod<Input = unknown, Output = unknown, Static extends boolean = boolean> = ResolvedMethod<Input, Output, Static> & {
+    readonly executable: true;
+};
 export {};

package/dist/v1/language/class/facets.d.ts

@@ -1,4 +1,5 @@
 import type { CallableInputOf, CallableOutputOf, ResolvedMethod, ResolvedMethodCollection } from '../callable/resolved.js';
+import type { StateTopology } from '../state/index.js';
 import type { ResolvedProperty, ResolvedPropertyCollection } from './resolved.js';
 type MemberName = string | number | symbol;
 type ValueAt<Collection, Key> = Key extends keyof Collection ? Collection[Key] : never;
@@ -17,7 +18,7 @@ type MethodByKeyOf<Class> = MethodCollectionOf<Class> extends {
     readonly byKey: infer ByKey extends Readonly<Record<string, ResolvedMethod>>;
 } ? ByKey : Readonly<Record<never, never>>;
 type MethodByNameOf<Class> = Pick<MethodCollectionOf<Class>, Exclude<keyof MethodCollectionOf<Class>, keyof ResolvedMethodCollection>>;
-export type PropertyOutputOf<Property> = Property extends ResolvedProperty<infer Value, infer Required> ? Required extends true ? Value : Value | undefined : never;
+export type PropertyOutputOf<Property> = Property extends ResolvedProperty<infer Value, infer Required, StateTopology | undefined, unknown> ? Required extends true ? Value : Value | undefined : never;
 /** Collision-safe direct Property values. Client supplies graph/wrapper reserved names. */
 export type PropertyShortcutsOf<Class, Reserved extends MemberName = never> = Readonly<{
     [Name in Exclude<keyof PropertyByNameOf<Class>, keyof MethodByNameOf<Class> | Reserved>]: PropertyOutputOf<ValueAt<PropertyByNameOf<Class>, Name>>;
@@ -40,7 +41,9 @@ export type CallableResultOf<Callable, Binary = unknown> = CallableOutputOf<Call
 } ? AsyncIterable<Item> : Output extends {
     readonly mode: 'binary';
 } ? Binary : never : never;
-type ExecutableMethod<Method> = Method extends ResolvedMethod<unknown, unknown, false, infer Inheritance> ? Inheritance extends 'abstract' ? never : Method : never;
+type ExecutableMethod<Method> = Method extends ResolvedMethod<unknown, unknown, false> & {
+    readonly executable: true;
+} ? Method : never;
 export type BoundMethodOf<Method, Binary = unknown> = ExecutableMethod<Method> extends infer Callable ? [Callable] extends [never] ? never : (input: CallableInputOf<Callable>) => Promise<CallableResultOf<Callable, Binary>> : never;
 /** Collision-safe direct bound Methods. Client supplies graph/wrapper reserved names. */
 export type BoundMethodShortcutsOf<Class, Binary = unknown, Reserved extends MemberName = never> = Readonly<{

package/dist/v1/language/class/inheritance.d.ts

@@ -0,0 +1,12 @@
+import type { ClassRef } from '../../addressing/index.js';
+import type { ClassKind } from './model/class.js';
+/** The representation shared by source, compiled and resolved Class admission. */
+export interface ClassInheritance {
+    readonly ref: ClassRef;
+    readonly kind: ClassKind;
+    readonly extends: readonly ClassRef[];
+}
+/** Kernel graph roots are intrinsic supertypes, not authored structural Edge contracts. */
+export declare function isGraphRoot(value: Pick<ClassInheritance, 'ref' | 'kind'>): boolean;
+/** Same-kind satisfaction includes the intrinsic root and the declared parent closure. */
+export declare function classSatisfies(candidate: ClassInheritance, required: ClassInheritance, resolve: (ref: ClassRef) => ClassInheritance | undefined): boolean;

package/dist/v1/language/class/inheritance.js

@@ -0,0 +1,25 @@
+/** Kernel graph roots are intrinsic supertypes, not authored structural Edge contracts. */
+export function isGraphRoot(value) {
+    return (value.ref.origin === 'kernel.astrale.ai' &&
+        value.ref.name === (value.kind === 'node' ? 'Node' : 'Edge'));
+}
+/** Same-kind satisfaction includes the intrinsic root and the declared parent closure. */
+export function classSatisfies(candidate, required, resolve) {
+    if (candidate.kind !== required.kind)
+        return false;
+    if (isGraphRoot(required))
+        return true;
+    const seen = new Set();
+    const visit = (value) => {
+        if (value.ref.origin === required.ref.origin && value.ref.name === required.ref.name)
+            return true;
+        if (seen.has(value))
+            return false;
+        seen.add(value);
+        return value.extends.some((ref) => {
+            const parent = resolve(ref);
+            return parent !== undefined && parent.kind === required.kind && visit(parent);
+        });
+    };
+    return visit(candidate);
+}

package/dist/v1/language/class/lifetime.d.ts

@@ -0,0 +1,17 @@
+import type { ClassRef } from '../../addressing/index.js';
+import type { EdgeContract } from './model/edge.js';
+/**
+ * What deleting the Node at one endpoint does to an Edge: `restrict` requires the transition to
+ * delete the Edge explicitly; `detach` deletes the Edge with the Node.
+ */
+export type EdgeLifetime = 'restrict' | 'detach';
+/**
+ * The lifetime of each endpoint of an Edge Class, in endpoint order (source then target, or the two
+ * incident endpoints), derived from the contract its Domain `origin` declares.
+ *
+ * An Edge Class binds only the Nodes of its own Domain and of the Domains that depend on it. An
+ * endpoint that accepts a Class `origin` does not own can therefore reach a Node it does not bind,
+ * and such a foreign endpoint detaches, unless an endpoint declares a minimum count that
+ * detaching would break. Every other endpoint restricts.
+ */
+export declare function edgeLifetimes(origin: ClassRef['origin'], contract: EdgeContract): readonly [EdgeLifetime, EdgeLifetime];

package/dist/v1/language/class/lifetime.js

@@ -0,0 +1,26 @@
+/**
+ * The lifetime of each endpoint of an Edge Class, in endpoint order (source then target, or the two
+ * incident endpoints), derived from the contract its Domain `origin` declares.
+ *
+ * An Edge Class binds only the Nodes of its own Domain and of the Domains that depend on it. An
+ * endpoint that accepts a Class `origin` does not own can therefore reach a Node it does not bind,
+ * and such a foreign endpoint detaches, unless an endpoint declares a minimum count that
+ * detaching would break. Every other endpoint restricts.
+ */
+export function edgeLifetimes(origin, contract) {
+    const endpoints = contract.orientation === 'directed'
+        ? [
+            [contract.endpoints.source.accepts, contract.endpoints.source.outgoing],
+            [contract.endpoints.target.accepts, contract.endpoints.target.incoming],
+        ]
+        : [
+            [contract.endpoints[0].accepts, contract.endpoints[0].incident],
+            [contract.endpoints[1].accepts, contract.endpoints[1].incident],
+        ];
+    const required = endpoints.some(([, count]) => minimum(count) > 0);
+    const lifetime = ([accepts]) => !required && accepts.some((ref) => ref.origin !== origin) ? 'detach' : 'restrict';
+    return Object.freeze([lifetime(endpoints[0]), lifetime(endpoints[1])]);
+}
+function minimum(count) {
+    return count === '1' || count === '1..*' ? 1 : 0;
+}

package/dist/v1/language/class/model/class.d.ts

@@ -1,15 +1,19 @@
-import type { ClassRef, DefinitionBase, PolicyRef } from '../../../addressing/index.js';
+import type { ClassRef, DefinitionBase } from '../../../addressing/index.js';
 import type { MethodRecord } from '../../callable/model/callable.js';
+import type { ClassPolicy, NodeClassPolicy } from '../../policy/model/policy.js';
 import type { DataFacet } from './data.js';
 import type { EdgeContract } from './edge.js';
 import type { PropertyFacet } from './property.js';
 export type ClassKind = 'node' | 'edge';
+/** An absent observation rule admits every caller; a delegation is still scoped by its ceiling. */
 export interface NodeClassPolicies {
-    readonly read?: PolicyRef;
-    readonly traverse?: PolicyRef;
+    readonly read?: NodeClassPolicy;
+    readonly traverse?: NodeClassPolicy;
 }
+/** An absent observation rule admits every caller; a delegation is still scoped by its ceiling. */
 export interface EdgeClassPolicies {
-    readonly traverse?: PolicyRef;
+    readonly read?: ClassPolicy;
+    readonly traverse?: ClassPolicy;
 }
 export interface NodeClassDefinition extends DefinitionBase<ClassRef>, PropertyFacet, DataFacet {
     readonly kind: 'node';

package/dist/v1/language/class/model/property.d.ts

@@ -1,6 +1,7 @@
-export type PropertyVisibility = 'public' | 'private';
 export type AutoEvent = 'create' | 'update';
 export type AutoSet = 'instant';
+/** `create`: written only by node or edge creation. `once`: written while absent, never unset. */
+export type PropertyImmutability = 'create' | 'once';
 export interface PropertyAuto {
     readonly on: readonly AutoEvent[];
     readonly set: AutoSet;
@@ -8,9 +9,10 @@ export interface PropertyAuto {
 export interface PropertyDefinition {
     readonly schema: import('../../value/model/schema.js').JsonSchema;
     readonly required: boolean;
-    readonly visibility: PropertyVisibility;
     readonly auto?: PropertyAuto;
+    readonly immutable?: PropertyImmutability;
     readonly description?: string;
+    readonly state?: import('../../state/index.js').StateTopology;
 }
 export type PropertyRecord = Readonly<Record<string, PropertyDefinition>>;
 export interface PropertyFacet {

package/dist/v1/language/class/property-values.js

@@ -1,7 +1,8 @@
-import { accept as acceptPortable } from '@astrale-os/kernel-dsl/value';
+import { acceptPropertyRoot } from '../../../value/accept.js';
+import { isImmutableSnapshot } from '../../../value/immutable.optimization.js';
 import { PropertyKey as admitPropertyKey } from '../../addressing/index.js';
 export function acceptPropertyValues(input, pointer = '') {
-    const admitted = acceptPortable(input);
+    const admitted = acceptPropertyRoot(input);
     if (admitted === null || typeof admitted !== 'object' || Array.isArray(admitted)) {
         throw new TypeError(`Expected PropertyValues object at ${pointer || '/'}.`);
     }
@@ -21,6 +22,8 @@ export const PropertyValues = Object.freeze({
 function freeze(value) {
     if (value === null || typeof value !== 'object')
         return value;
+    if (isImmutableSnapshot(value))
+        return value;
     for (const member of Object.values(value))
         freeze(member);
     return Object.freeze(value);

package/dist/v1/language/class/resolved.d.ts

@@ -1,32 +1,34 @@
 import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
-import type { ClassRef, DefinitionKey, Key, PolicyRef, PropertyKey } from '../../addressing/index.js';
+import type { ClassRef, DefinitionKey, Key, PropertyKey } from '../../addressing/index.js';
 import type { ResolvedMethodCollection } from '../callable/resolved.js';
+import type { StateTopology } from '../state/index.js';
 import type { Diagnostic } from '../validation/diagnostic.js';
+import type { ValueProgram } from '../value/compile/model.js';
 import type { OrderingKind } from '../value/ordering.js';
 import type { ClassDefinition, ClassKind } from './model/class.js';
 import type { DataDefinition } from './model/data.js';
 import type { PropertyDefinition } from './model/property.js';
 import type { PropertyValues } from './property-values.js';
-export interface ResolvedProperty<out Value = PortableValue, out Required extends boolean = boolean> {
+export interface ResolvedProperty<out Value = PortableValue, out Required extends boolean = boolean, out State extends StateTopology | undefined = StateTopology | undefined, out Input = Value> {
     readonly owner: AnyResolvedClass;
     readonly name: string;
     readonly key: PropertyKey;
-    readonly definition: PropertyDefinition & {
+    readonly definition: Omit<PropertyDefinition, 'required' | 'state'> & {
         readonly required: Required;
+        readonly state?: State;
     };
     /** The one portable scalar ordering domain, when the Property is orderable. */
     readonly ordering?: OrderingKind;
     validate(input: unknown): readonly Diagnostic[];
+    /** The admitted program `validate` evaluates. */
+    program(): ValueProgram;
     readonly __value?: Value;
+    readonly __input?: Input;
 }
 export interface ResolvedData {
     readonly owner: ResolvedClass<'node'>;
     readonly definition: DataDefinition;
 }
-export interface ResolvedClassPolicies<Kind extends ClassKind = ClassKind> {
-    readonly read: Kind extends 'node' ? readonly PolicyRef[] : readonly [];
-    readonly traverse: readonly PolicyRef[];
-}
 export type ResolvedPropertyCollection<ByKey extends Readonly<Record<PropertyKey, ResolvedProperty<unknown>>> = Readonly<Record<PropertyKey, ResolvedProperty<unknown>>>, ByName extends Readonly<Record<string, ResolvedProperty<unknown>>> = Readonly<Record<never, never>>> = Readonly<ByName> & Iterable<ByKey[keyof ByKey]> & {
     readonly byKey: ByKey;
     get<Key extends keyof ByKey>(key: Key): ByKey[Key];
@@ -43,9 +45,10 @@ export interface ResolvedClass<Kind extends ClassKind = ClassKind, Properties ex
     readonly kind: Kind;
     readonly abstract: boolean;
     readonly definition: Definition;
+    /** Explicitly authored parents; intrinsic graph roots do not alter schema bytes. */
     readonly extends: Parents & readonly ResolvedClass<Kind>[];
-    /** Effective inherited Policy conjunction, deduplicated by exact Policy ref. */
-    readonly policies: ResolvedClassPolicies<Kind>;
+    /** Local observation Policies; Class inheritance never contributes an attachment. */
+    readonly policies: Definition['policies'];
     readonly data: Kind extends 'node' ? ResolvedData | undefined : undefined;
     readonly properties: Properties;
     readonly methods: Kind extends 'node' ? InstanceMethods : ResolvedMethodCollection<Record<never, never>>;
@@ -55,31 +58,32 @@ export interface ResolvedClass<Kind extends ClassKind = ClassKind, Properties ex
     readonly self: {
         readonly data: Kind extends 'node' ? ResolvedData | undefined : undefined;
         readonly properties: SelfProperties;
-        /** Policies declared by this exact Class only. */
-        readonly policies: Definition['policies'];
         readonly methods: Kind extends 'node' ? SelfInstanceMethods : ResolvedMethodCollection<Record<never, never>>;
         readonly static: {
             readonly methods: Kind extends 'node' ? SelfStaticMethods : ResolvedMethodCollection<Record<never, never>>;
         };
     };
+    /** Same-kind nominal inheritance, including the universal Kernel Node or Edge root. */
     satisfies(selected: ResolvedClass<Kind>): boolean;
     validateProperties(input: unknown): readonly Diagnostic[];
 }
 /** One resolved Class with an exact graph kind, used at heterogeneous Domain boundaries. */
 export type AnyResolvedClass = ResolvedClass<'node'> | ResolvedClass<'edge'>;
-/** Exact Class keys satisfied by one resolved Class, including transitive parents. */
+/** Class keys satisfied by one resolved Class, including its graph root and transitive parents. */
 export type ClassSatisfactionKeysOf<Class> = ClassSatisfactionKeys<Class, never>;
 type ClassSatisfactionKeys<Class, Seen> = Class extends Seen ? never : (Class extends {
+    readonly kind: infer Kind extends ClassKind;
+} ? DefinitionKey<'kernel.astrale.ai', 'class', Kind extends 'node' ? 'Node' : 'Edge'> : never) | (Class extends {
     readonly key: infer ExactKey extends DefinitionKey<Key.Origin, 'class'>;
 } ? ExactKey : never) | (Class extends ResolvedClass<ClassKind, ResolvedPropertyCollection, ResolvedMethodCollection, ResolvedMethodCollection, ResolvedPropertyCollection, ResolvedMethodCollection, ResolvedMethodCollection, ClassDefinition, infer Parents> ? ClassSatisfactionKeys<Extract<Parents[number], ResolvedClass>, Seen | Class> : never);
-export type PropertyValueOf<Property> = Property extends ResolvedProperty<infer Value> ? Value : never;
+export type PropertyValueOf<Property> = Property extends ResolvedProperty<infer Value, boolean, StateTopology | undefined, unknown> ? Value : never;
 export type PropertiesOf<Class> = Class extends {
     readonly properties: infer Properties extends ResolvedPropertyCollection;
 } ? Properties : ResolvedPropertyCollection<Record<never, never>>;
 export type PropertyValuesOf<Class> = PropertyValues & Readonly<{
     [Key in keyof PropertyByKeyOf<Class>]?: PropertyValueOf<PropertyByKeyOf<Class>[Key]>;
 }>;
-export type PropertyInputOf<Class> = PropertyInput<PropertyByKeyOf<Class>, PropertyByNameOf<Class>>;
+export type PropertyInputOf<Class> = PropertyWriteInput<PropertyByKeyOf<Class>, PropertyByNameOf<Class>>;
 export type MethodsOf<Class> = Class extends {
     readonly kind: 'node';
     readonly methods: infer Methods extends ResolvedMethodCollection;
@@ -114,10 +118,16 @@ type PropertyInput<ByKey extends Readonly<Record<PropertyKey, ResolvedProperty<u
 } & {
     [Name in keyof ByName]?: PropertyValueOf<ByName[Name]>;
 }>;
+type PropertyWriteInput<ByKey extends Readonly<Record<PropertyKey, ResolvedProperty<unknown>>>, ByName extends Readonly<Record<string, ResolvedProperty<unknown>>>> = Readonly<{
+    [Key in keyof ByKey]?: PropertyWriteValueOf<ByKey[Key]>;
+} & {
+    [Name in keyof ByName]?: PropertyWriteValueOf<ByName[Name]>;
+}>;
+type PropertyWriteValueOf<Property> = Property extends ResolvedProperty<unknown, boolean, StateTopology | undefined, infer Input> ? Input : never;
 type PropertyByKeyOf<Class> = PropertiesOf<Class> extends {
     readonly byKey: infer ByKey extends Readonly<Record<PropertyKey, ResolvedProperty<unknown>>>;
 } ? ByKey : Readonly<Record<never, never>>;
 type PropertyByNameOf<Class> = Readonly<{
-    [Name in Exclude<keyof PropertiesOf<Class>, keyof ResolvedPropertyCollection>]: Extract<PropertiesOf<Class>[Name], ResolvedProperty>;
+    [Name in Exclude<keyof PropertiesOf<Class>, keyof ResolvedPropertyCollection>]: Extract<PropertiesOf<Class>[Name], ResolvedProperty<unknown, boolean, StateTopology | undefined, unknown>>;
 }>;
 export {};

package/dist/v1/language/core/model/core.d.ts

@@ -1,9 +1,15 @@
 import type { ClassRef, CoreRef, DefinitionBase } from '../../../addressing/index.js';
 import type { PropertyValues } from '../../class/property-values.js';
+import type { PolicyObjectRef } from '../../policy/model/policy.js';
 export interface DomainEndpointRef {
     readonly kind: 'domain';
 }
-export type CoreEndpointRef = CoreRef | DomainEndpointRef;
+/**
+ * One Core Edge endpoint: the owning Domain itself, or any local Definition whose installed
+ * projection resolves through an exact member Path. That is the same projected-member vocabulary
+ * a Policy object names, so both languages address one identity the same way.
+ */
+export type CoreEndpointRef = PolicyObjectRef | DomainEndpointRef;
 export interface CoreDefinition extends DefinitionBase<CoreRef> {
     readonly class: ClassRef;
     readonly properties: PropertyValues;

package/dist/v1/language/core/resolved.d.ts

@@ -1,6 +1,8 @@
 import type { DefinitionKey } from '../../addressing/index.js';
+import type { ResolvedMethod } from '../callable/resolved.js';
 import type { PropertyValues } from '../class/property-values.js';
 import type { ResolvedClass } from '../class/resolved.js';
+import type { ResolvedDefinition } from '../resolved.js';
 import type { CoreDefinition } from './model/core.js';
 export interface ResolvedCoreDefinition {
     readonly ref: CoreDefinition['ref'];
@@ -13,9 +15,11 @@ export interface ResolvedDomainEndpoint {
     readonly kind: 'domain';
     readonly origin: string;
 }
+/** The owning Domain, one local Definition, or one local Class-owned Method. */
+export type ResolvedCoreEndpoint = ResolvedDefinition | ResolvedMethod | ResolvedDomainEndpoint;
 export interface ResolvedCoreEdge {
     readonly class: ResolvedClass<'edge'>;
-    readonly source: ResolvedCoreDefinition | ResolvedDomainEndpoint;
-    readonly target: ResolvedCoreDefinition | ResolvedDomainEndpoint;
+    readonly source: ResolvedCoreEndpoint;
+    readonly target: ResolvedCoreEndpoint;
     readonly properties: PropertyValues;
 }

package/dist/v1/language/definition/metadata.d.ts

@@ -10,3 +10,11 @@ export declare const icon: Readonly<{
     readonly minLength: 1;
     readonly maxLength: 8000;
 }>;
+/** Exact V1 bound for the required human-facing display name a new Domain revision declares. */
+export declare const name: Readonly<{
+    readonly type: 'string';
+    readonly minLength: 1;
+    readonly maxLength: 100;
+}>;
+/** The common source and compiled grammar for a name displayed exactly as authored. */
+export declare function isDomainNameText(value: string): boolean;

package/dist/v1/language/definition/metadata.js

@@ -10,3 +10,15 @@ export const icon = Object.freeze({
     minLength: 1,
     maxLength: 8000,
 });
+/** Exact V1 bound for the required human-facing display name a new Domain revision declares. */
+export const name = Object.freeze({
+    type: 'string',
+    minLength: 1,
+    maxLength: 100,
+});
+// oxlint-disable-next-line no-control-regex
+const DOMAIN_NAME_CONTROL = /[\u0000-\u001f\u007f-\u009f\u2028\u2029]/u;
+/** The common source and compiled grammar for a name displayed exactly as authored. */
+export function isDomainNameText(value) {
+    return value.trim() === value && !DOMAIN_NAME_CONTROL.test(value);
+}

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

@@ -1,12 +1,20 @@
+export { isMethodExecutable } from './callable/executable.js';
+export { isBinaryInput } from './callable/model/callable.js';
 export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, FunctionRef, MethodKey, PolicyRef, PropertyKey, ViewRef, } from '../addressing/index.js';
 export type { Value as PropertyValue } from '@astrale-os/kernel-dsl/value';
 export type { JsonSchema as ValueSchema, JsonSchemaObject as ValueSchemaObject, } from './value/model/schema.js';
 export type { OrderingKind } from './value/ordering.js';
+export type { ValueProgram } from './value/compile/model.js';
+export { valueProgramIncludes } from './value/inclusion/includes.js';
+export { stateMachine } from './state/index.js';
+export type { EventOf, StateMachine, StateOf, StateTopology } from './state/index.js';
 export type * from './callable/model/callable.js';
 export type * from './callable/resolved.js';
 export type * from './class/model/class.js';
 export type { DataDefinition, DataFacet, MediaType } from './class/model/data.js';
 export type * from './class/model/edge.js';
+export { edgeLifetimes } from './class/lifetime.js';
+export type { EdgeLifetime } from './class/lifetime.js';
 export type * from './class/model/property.js';
 export type * from './class/resolved.js';
 export type * from './class/facets.js';
@@ -18,6 +26,7 @@ export type { Definition } from './definition.js';
 export type { ResolvedDefinition, ResolvedDefinitionOf } from './resolved.js';
 export type { Diagnostic, DiagnosticCode } from './validation/diagnostic.js';
 export type * from './policy/model/policy.js';
+export { isClassRuleChecks, policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, projectedMemberClass, } from './policy/model/policy.js';
 export type * from './policy/resolved.js';
 export type * from './view/model/view.js';
 export type * from './view/resolved.js';

package/dist/v1/language/index.js

@@ -1 +1,7 @@
+export { isMethodExecutable } from './callable/executable.js';
+export { isBinaryInput } from './callable/model/callable.js';
+export { valueProgramIncludes } from './value/inclusion/includes.js';
+export { stateMachine } from './state/index.js';
+export { edgeLifetimes } from './class/lifetime.js';
 export { PropertyValues } from './class/property-values.js';
+export { isClassRuleChecks, policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, projectedMemberClass, } from './policy/model/policy.js';

package/dist/v1/language/policy/analysis/branches.d.ts

@@ -1,8 +1,9 @@
-import type { ClassRef } from '../../../addressing/index.js';
-import type { PolicyEdgePattern, PolicyPatternExpression, PolicyPatternTerm } from '../model/policy.js';
+import type { PolicyEdgePattern, PolicyPatternExpression, PolicyPatternTerm, PolicyVariableSelector } from '../model/policy.js';
 export interface PatternBranch {
+    readonly terms: ReadonlyMap<string, PolicyPatternTerm>;
+    readonly equalities: readonly (readonly [string, string])[];
     readonly edges: readonly PatternEdgeUse[];
-    readonly variables: ReadonlyMap<string, ClassRef>;
+    readonly variables: ReadonlyMap<string, PolicyVariableSelector>;
     readonly requiredVariables: ReadonlySet<string>;
     readonly namespace: string;
 }

package/dist/v1/language/policy/analysis/branches.js

@@ -1,3 +1,5 @@
+import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { policyObjectKey, policyVariableSelector } from '../model/policy.js';
 import { BRANCH_OVERFLOW } from './budgets.js';
 export function branchesOf(pattern, namespace) {
     const variables = collectVariableClasses(pattern, namespace);
@@ -25,7 +27,7 @@ export function isConnected(branch) {
     const mode = targetMode(branch);
     if (mode === undefined)
         return false;
-    const vertices = new Set(mode === 'object' ? ['subject', 'object'] : ['subject', 'source', 'target']);
+    const vertices = new Set(['subject', ...branch.terms.keys()]);
     for (const variable of branch.requiredVariables)
         vertices.add(variable);
     const union = new UnionFind(vertices);
@@ -36,6 +38,8 @@ export function isConnected(branch) {
         union.add(target);
         union.join(source, target);
     }
+    for (const [left, right] of branch.equalities)
+        union.join(left, right);
     const root = union.find('subject');
     return [...vertices].every((vertex) => union.find(vertex) === root);
 }
@@ -43,25 +47,54 @@ export function targetMode(branch) {
     let object = false;
     let source = false;
     let target = false;
-    for (const edge of branch.edges) {
-        for (const term of [edge.pattern.source, edge.pattern.target]) {
-            object ||= term.kind === 'object';
-            source ||= term.kind === 'source';
-            target ||= term.kind === 'target';
-        }
+    for (const term of branch.terms.values()) {
+        object ||= term.kind === 'object';
+        source ||= term.kind === 'source';
+        target ||= term.kind === 'target';
     }
     if (object && !source && !target)
         return 'object';
-    if (!object && source && target)
+    if (!object && (source || target))
         return 'edge';
     return undefined;
 }
 export function termKey(term, namespace) {
-    return term.kind === 'variable' ? variableKey(namespace, term.id) : term.kind;
+    return term.kind === 'variable'
+        ? variableKey(namespace, term.id)
+        : term.kind === 'ref'
+            ? `ref:${term.ref.kind === 'method' ? policyObjectKey(term.ref) : definitionRefIndex(term.ref)}`
+            : term.kind;
 }
 function branchesForNode(pattern, namespace, variables) {
     if ('source' in pattern) {
-        return [{ edges: [{ pattern, namespace }], variables, requiredVariables: new Set(), namespace }];
+        return [
+            {
+                terms: new Map([pattern.source, pattern.target].map((term) => [termKey(term, namespace), term])),
+                equalities: [],
+                edges: [{ pattern, namespace }],
+                variables,
+                requiredVariables: new Set(),
+                namespace,
+            },
+        ];
+    }
+    if ('sameNode' in pattern) {
+        const terms = new Map([pattern.sameNode.left, pattern.sameNode.right].map((term) => [
+            termKey(term, namespace),
+            term,
+        ]));
+        return [
+            {
+                terms,
+                equalities: [
+                    [termKey(pattern.sameNode.left, namespace), termKey(pattern.sameNode.right, namespace)],
+                ],
+                edges: [],
+                variables,
+                requiredVariables: new Set(),
+                namespace,
+            },
+        ];
     }
     if ('exists' in pattern) {
         const direct = new Set(pattern.exists.nodes.map((node) => variableKey(namespace, node.variable.id)));
@@ -74,10 +107,19 @@ function branchesForNode(pattern, namespace, variables) {
     return 'allOf' in pattern ? branchProduct(children) : capBranches(children.flat());
 }
 function emptyBranch() {
-    return { edges: [], variables: new Map(), requiredVariables: new Set(), namespace: '$' };
+    return {
+        terms: new Map(),
+        equalities: [],
+        edges: [],
+        variables: new Map(),
+        requiredVariables: new Set(),
+        namespace: '$',
+    };
 }
 function mergeBranches(left, right) {
     return {
+        terms: new Map([...left.terms, ...right.terms]),
+        equalities: [...left.equalities, ...right.equalities],
         edges: [...left.edges, ...right.edges],
         variables: new Map([...left.variables, ...right.variables]),
         requiredVariables: new Set([...left.requiredVariables, ...right.requiredVariables]),
@@ -89,7 +131,7 @@ function collectVariableClasses(pattern, namespace) {
     const visit = (node) => {
         if ('exists' in node) {
             for (const variable of node.exists.nodes) {
-                result.set(variableKey(namespace, variable.variable.id), variable.class);
+                result.set(variableKey(namespace, variable.variable.id), policyVariableSelector(variable));
             }
             visit(node.exists.where);
         }

package/dist/v1/language/policy/analysis/budgets.js

@@ -8,7 +8,7 @@ export const MAX_CHECK_DEPTH = 4;
 export const MAX_CHECK_LEAVES = 8;
 export const BRANCH_OVERFLOW = MAX_BRANCHES + 1;
 export function measureChecks(expression) {
-    if ('check' in expression)
+    if ('check' in expression || 'sameNode' in expression)
         return { depth: 1, branches: 1, leaves: 1 };
     const children = ('allOf' in expression ? expression.allOf : expression.anyOf).map(measureChecks);
     const branches = 'allOf' in expression