@astrale-os/kernel-dsl 1.0.0-beta.8 → 1.0.0-beta.9

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

@@ -152,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) {

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/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_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_EDGE_LIFETIME' | '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_UNIQUE_PROPERTY' | '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_CLASS_INHERITANCE' | '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_EDGE_LIFETIME' | '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_UNIQUE_PROPERTY' | '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/language/class/inheritance.d.ts

@@ -6,6 +6,8 @@ export interface ClassAncestry {
     readonly kind: ClassKind;
     readonly extends: readonly ClassRef[];
 }
+/** The origin of the Kernel, whose Schema every Domain depends on. */
+export declare const KERNEL_ORIGIN = "kernel.astrale.ai";
 /** Kernel graph roots are intrinsic supertypes, not authored structural Edge contracts. */
 export declare function isGraphRoot(value: Pick<ClassAncestry, 'ref' | 'kind'>): boolean;
 /** Same-kind satisfaction includes the intrinsic root and the declared parent closure. */
@@ -14,3 +16,10 @@ export declare function classSatisfies(candidate: ClassAncestry, required: Class
 export declare function inheritanceOf(declaration: {
     readonly inheritance?: Inheritance;
 }): Inheritance;
+/**
+ * Whether a Class of another Domain may extend this Class: only an `'open'` one admits it. Its own
+ * Domain may extend any Class that is not `'final'`.
+ */
+export declare function admitsForeignSubclass(declaration: {
+    readonly inheritance?: Inheritance;
+}): boolean;

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

@@ -1,6 +1,8 @@
+/** The origin of the Kernel, whose Schema every Domain depends on. */
+export const KERNEL_ORIGIN = 'kernel.astrale.ai';
 /** Kernel graph roots are intrinsic supertypes, not authored structural Edge contracts. */
 export function isGraphRoot(value) {
-    return (value.ref.origin === 'kernel.astrale.ai' &&
+    return (value.ref.origin === KERNEL_ORIGIN &&
         value.ref.name === (value.kind === 'node' ? 'Node' : 'Edge'));
 }
 /** Same-kind satisfaction includes the intrinsic root and the declared parent closure. */
@@ -27,3 +29,10 @@ export function classSatisfies(candidate, required, resolve) {
 export function inheritanceOf(declaration) {
     return declaration.inheritance ?? 'internal';
 }
+/**
+ * Whether a Class of another Domain may extend this Class: only an `'open'` one admits it. Its own
+ * Domain may extend any Class that is not `'final'`.
+ */
+export function admitsForeignSubclass(declaration) {
+    return inheritanceOf(declaration) === 'open';
+}

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

@@ -21,7 +21,9 @@ export interface ContractEndpoint {
 export declare function contractEndpoints(contract: EdgeContract): readonly [ContractEndpoint, ContractEndpoint];
 /**
  * Whether an endpoint of an Edge Class of `origin` can hold a Node of another Domain: it accepts a
- * Class `origin` does not own, or one another Domain may extend.
+ * Class `origin` does not own, or one another Domain may extend. The Kernel's own relations are the
+ * exception: every Domain depends on the Kernel and extends its roots, so its relations bind every
+ * Node and keep the lifetimes they have as closed Classes, however open the Kernel's Classes are.
  */
 export declare function reachesAnotherDomain(origin: ClassRef['origin'], endpoint: EdgeEndpointBase, scope: LifetimeScope): boolean;
 /**

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

@@ -1,4 +1,5 @@
 import { definitionRefIndex } from '../../addressing/ordering.js';
+import { KERNEL_ORIGIN } from './inheritance.js';
 /** The lifetime scope of `classes`. */
 export function lifetimeScope(classes) {
     const declarations = new Map();
@@ -35,10 +36,12 @@ export function contractEndpoints(contract) {
 }
 /**
  * Whether an endpoint of an Edge Class of `origin` can hold a Node of another Domain: it accepts a
- * Class `origin` does not own, or one another Domain may extend.
+ * Class `origin` does not own, or one another Domain may extend. The Kernel's own relations are the
+ * exception: every Domain depends on the Kernel and extends its roots, so its relations bind every
+ * Node and keep the lifetimes they have as closed Classes, however open the Kernel's Classes are.
  */
 export function reachesAnotherDomain(origin, endpoint, scope) {
-    return endpoint.accepts.some((ref) => ref.origin !== origin || scope.extendable(ref));
+    return endpoint.accepts.some((ref) => ref.origin !== origin || (origin !== KERNEL_ORIGIN && scope.extendable(ref)));
 }
 /**
  * The lifetime of each endpoint of `edge`, in endpoint order: the one it declares, else the derived

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

@@ -14,7 +14,7 @@ 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 { inheritanceOf } from './class/inheritance.js';
+export { admitsForeignSubclass, inheritanceOf } from './class/inheritance.js';
 export { edgeLifetimes, lifetimeScope } from './class/lifetime.js';
 export type { LifetimeScope } from './class/lifetime.js';
 export { EDGE_UNIQUE_FORMS, NODE_UNIQUE_FORMS, NO_UNIQUE_FORMS, UNIQUE_FORMS, compareEdgeUniqueFields, compareEdgeUniqueTuples, compareNodeUniqueTuples, coveringEdgeUniqueTuples, coveringNodeUniqueTuples, edgeUniqueForm, edgeUniqueFormOf, edgeUniqueKeys, edgeUniqueTuple, edgeUniqueValue, edgeUniqueValues, enforcesEdgeUniqueTuple, enforcesNodeUniqueTuple, keyableProperty, nodeUniqueForm, nodeUniqueKeys, nodeUniqueTuple, nodeUniqueValue, nodeUniqueValues, } from './class/unique.js';

package/dist/v1/language/index.js

@@ -3,7 +3,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 { inheritanceOf } from './class/inheritance.js';
+export { admitsForeignSubclass, inheritanceOf } from './class/inheritance.js';
 export { edgeLifetimes, lifetimeScope } from './class/lifetime.js';
 export { EDGE_UNIQUE_FORMS, NODE_UNIQUE_FORMS, NO_UNIQUE_FORMS, UNIQUE_FORMS, compareEdgeUniqueFields, compareEdgeUniqueTuples, compareNodeUniqueTuples, coveringEdgeUniqueTuples, coveringNodeUniqueTuples, edgeUniqueForm, edgeUniqueFormOf, edgeUniqueKeys, edgeUniqueTuple, edgeUniqueValue, edgeUniqueValues, enforcesEdgeUniqueTuple, enforcesNodeUniqueTuple, keyableProperty, nodeUniqueForm, nodeUniqueKeys, nodeUniqueTuple, nodeUniqueValue, nodeUniqueValues, } from './class/unique.js';
 export { PropertyValues } from './class/property-values.js';

package/dist/v1/schema/compatibility/api.d.ts

@@ -1,3 +1,4 @@
 export { compare, compareMeaning, compareStructure } from './compare.js';
+export { closedParents } from './extension.js';
 export { requiredBump } from './versioning/index.js';
 export type { Analysis, Assessment, Bump, Comparison, ComparisonEntry, ComparisonEvidence, ComparisonRequest, ComparisonScope, Facet, Fingerprint, MeaningComparison, Observation, RequiredBump, SchemaIdentity, StructureComparison, Subject, Usage, VersionChange, } from './model.js';

package/dist/v1/schema/compatibility/api.js

@@ -1,2 +1,3 @@
 export { compare, compareMeaning, compareStructure } from './compare.js';
+export { closedParents } from './extension.js';
 export { requiredBump } from './versioning/index.js';

package/dist/v1/schema/compatibility/extension.d.ts

@@ -0,0 +1,11 @@
+import type { Key } from '../../addressing/index.js';
+import type { DomainSchema } from '../model/schema.js';
+/**
+ * The Classes of the target's origin that a Class of the dependent extends and the target does not
+ * open to it, as Keys in order (DM-CLASS-INHERITANCE). A parent the target no longer declares is
+ * not closed: losing it is an ancestry change.
+ */
+export declare function closedParents({ dependent, target, }: {
+    readonly dependent: DomainSchema;
+    readonly target: DomainSchema;
+}): readonly Key[];

package/dist/v1/schema/compatibility/extension.js

@@ -0,0 +1,22 @@
+import { compareUnicode } from '../../addressing/ordering.js';
+import { admitsForeignSubclass } from '../../language/class/inheritance.js';
+import { keyForDefinitionRef } from './coordinate.js';
+/**
+ * The Classes of the target's origin that a Class of the dependent extends and the target does not
+ * open to it, as Keys in order (DM-CLASS-INHERITANCE). A parent the target no longer declares is
+ * not closed: losing it is an ancestry change.
+ */
+export function closedParents({ dependent, target, }) {
+    const closed = new Set();
+    if (dependent.origin === target.origin)
+        return [];
+    for (const declaration of Object.values(dependent.classes))
+        for (const parent of declaration.extends) {
+            if (parent.origin !== target.origin)
+                continue;
+            const declared = target.classes[parent.name];
+            if (declared !== undefined && !admitsForeignSubclass(declared))
+                closed.add(keyForDefinitionRef(parent));
+        }
+    return Object.freeze([...closed].sort(compareUnicode));
+}

package/dist/v1/schema/compatibility/model.d.ts

@@ -17,6 +17,13 @@ export interface ComparisonRequest {
          * unresolvable or unsupported Key of the target origin, is rejected with DM_CAPABILITY_INVALID.
          */
         readonly capabilities?: readonly Key[];
+        /**
+         * `true` when the dependent already holds its binding to the target, as the installer holds
+         * one a Domain was installed with: the Classes of the target origin it extends are then not
+         * judged for inheritance (DM-CLASS-INHERITANCE). Otherwise each must be `'open'` in the
+         * target. It enters no evidence: a held comparison has the facts of a compatible judged one.
+         */
+        readonly held?: boolean;
     } | {
         readonly kind: 'members';
         readonly source: DomainSchema;

package/dist/v1/schema/compatibility/scope.d.ts

@@ -25,6 +25,8 @@ export interface ComparisonContext {
      * structure records them only when they fail, so a compatible comparison keeps its bytes.
      */
     readonly reliance: readonly Reference[];
+    /** Whether the dependent holds its binding to the target, so its extensions are not judged. */
+    readonly held: boolean;
     pair(coordinate: Coordinate): SubjectPair;
 }
 export declare function prepare(request: ComparisonRequest): ComparisonContext;

package/dist/v1/schema/compatibility/scope.js

@@ -42,6 +42,7 @@ export function prepare(request) {
         roots: [...rootReferences(dependent), ...capabilities],
         capabilities,
         reliance: policyReliance(dependent, source.origin),
+        held: scope.held === true,
     });
 }
 /**
@@ -63,9 +64,10 @@ export function selectMembers(source, target, keys) {
         })),
         capabilities: [],
         reliance: [],
+        held: false,
     });
 }
-function comparisonContext({ kind, source, target, dependent, before, roots, capabilities, reliance, }) {
+function comparisonContext({ kind, source, target, dependent, before, roots, capabilities, reliance, held, }) {
     resolve(target);
     const after = contextOf(target);
     const pairs = new Map();
@@ -78,6 +80,7 @@ function comparisonContext({ kind, source, target, dependent, before, roots, cap
         roots,
         capabilities,
         reliance,
+        held,
         scope: Object.freeze({
             kind,
             source: schemaIdentity(source),

package/dist/v1/schema/compatibility/structure/requirements.js

@@ -5,6 +5,7 @@ import { compareFacet } from '../comparators/index.js';
 import { fingerprintMeaning } from '../comparators/values.js';
 import { contextInvalid } from '../context.js';
 import { methodCoordinate } from '../coordinate.js';
+import { closedParents } from '../extension.js';
 import { callableReferences, classReferences, inherits, memberReferences, usageOf, valueReferences, } from '../references.js';
 /** Structure follows data and abstract obligations; concrete IO never expands its requirements. */
 export function compareRequirements({ context, report, }) {
@@ -98,27 +99,29 @@ function compareReliance({ context, report, }) {
     }
 }
 /**
- * A Class one of the dependent's own Classes extends must still admit it: the dependent is refused
- * once the compared origin declares that Class `'final'`. The fact is recorded only when it fails,
- * like a Policy reliance, so a compatible comparison keeps its evidence bytes.
+ * A Class of the compared origin one of the dependent's own Classes extends must be `'open'` in the
+ * target, unless the dependent holds its binding to that target. The fact is recorded only when it
+ * fails, like a Policy reliance, so a compatible comparison keeps its evidence bytes: `'open'`, what
+ * a subclass of another Domain requires, before, and the target's inheritance after.
  */
 function compareExtension({ context, report, }) {
+    if (context.held || context.dependent === undefined)
+        return;
+    const closed = new Set(closedParents({ dependent: context.dependent, target: context.target }));
+    if (closed.size === 0)
+        return;
     for (const reference of context.roots) {
-        if (reference.usage.relation !== 'extends')
-            continue;
-        if (Key.origin(reference.coordinate.key) !== context.source.origin)
+        if (reference.usage.relation !== 'extends' || !closed.has(reference.coordinate.key))
             continue;
         const pair = context.pair(reference.coordinate);
-        if (pair.source?.kind !== 'class' || pair.target?.kind !== 'class')
-            continue;
-        if (pair.target.analysis.declaration.inheritance !== 'final')
+        if (pair.target?.kind !== 'class')
             continue;
         report.note(reference);
         report.record({
             pair,
             facet: 'class.inheritance',
-            before: inheritanceMeaning(inheritanceOf(pair.source.analysis.declaration)),
-            after: inheritanceMeaning('final'),
+            before: inheritanceMeaning('open'),
+            after: inheritanceMeaning(inheritanceOf(pair.target.analysis.declaration)),
             requirement: { kind: 'class.inheritance' },
         });
     }

package/dist/v1/schema/compatibility/versioning/surface.js

@@ -1,4 +1,4 @@
-import { inheritanceOf } from '../../../language/class/inheritance.js';
+import { admitsForeignSubclass, inheritanceOf } from '../../../language/class/inheritance.js';
 import { methodInheritance } from '../comparators/callables.js';
 import { compareAddedProperties, inheritanceMeaning } from '../comparators/classes.js';
 import { compareFacet } from '../comparators/index.js';
@@ -57,16 +57,18 @@ export function compareSurface({ context, report, }) {
     }
 }
 /**
- * A changed inheritance is observed on its Class, and is major when the Class was `'open'` or
- * becomes `'final'`. Closing an `'open'` Class withdraws what its declaration granted other Domains;
- * acceptance refuses a subclass of a `'final'` Class of any Domain and admits one of another
- * Domain's `'internal'` Class (DV-CLASS-INHERITANCE), so finalizing that Class can refuse a dependent.
+ * A changed inheritance is observed on its Class, and is major when an `'open'` Class stops being
+ * open: only an `'open'` Class admits a subclass of another Domain (DM-CLASS-INHERITANCE). Closing
+ * or finalizing a Class no other Domain may extend takes nothing from a dependent; opening one
+ * grants an extension, which the floor, counting added members only, leaves at a patch.
  */
 function compareExtension({ pair, report, }) {
     if (pair.source?.kind !== 'class' || pair.target?.kind !== 'class')
         return;
-    const before = inheritanceOf(pair.source.analysis.declaration);
-    const after = inheritanceOf(pair.target.analysis.declaration);
+    const source = pair.source.analysis.declaration;
+    const target = pair.target.analysis.declaration;
+    const before = inheritanceOf(source);
+    const after = inheritanceOf(target);
     if (before === after)
         return;
     report.record({
@@ -74,7 +76,10 @@ function compareExtension({ pair, report, }) {
         facet: 'class.inheritance',
         before: inheritanceMeaning(before),
         after: inheritanceMeaning(after),
-        requirement: { kind: 'class.inheritance', satisfied: before !== 'open' && after !== 'final' },
+        requirement: {
+            kind: 'class.inheritance',
+            satisfied: !admitsForeignSubclass(source) || admitsForeignSubclass(target),
+        },
     });
 }
 function changed({ before, after }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "1.0.0-beta.8",
+  "version": "1.0.0-beta.9",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {