@astrale-os/kernel-core 0.4.1

package/dist/domain/compile/method/types.d.ts

@@ -0,0 +1,101 @@
+import type { ExtractMethods, FnDef, KindSegment, MethodInheritance, Schema } from '@astrale-os/kernel-dsl';
+import type { DefDescriptor } from '@astrale-os/kernel-dsl';
+import type { MethodPath } from '#domain/addressing/paths/method';
+import type { ClassDefNames, InterfaceDefNames } from '#domain/compile/catalog/def-types';
+import type { DomainInheritance } from './resolve';
+/**
+ * A fully-resolved method entry. Produced by walking the inheritance
+ * tree and resolving method ownership, overrides, and inheritance mode.
+ *
+ * The `inheritance` axis encodes how this class obtained the method:
+ *   - 'own'               — declared directly on this class, not overriding anything
+ *   - 'override'          — declared on this class, overriding a parent's default
+ *   - 'sealed'            — inherited from an interface, cannot be overridden
+ *   - 'inherited-default' — inherited from an interface's default implementation
+ *   - 'abstract'          — inherited abstract method; the class MUST provide a handler
+ */
+export interface ResolvedMethod {
+    /** The FnDef that defines this method's signature */
+    readonly fnDef: FnDef;
+    /** How this method was obtained by the owning class */
+    readonly inheritance: DomainInheritance;
+    /** Bare name of the def that originally declared this method */
+    readonly origin: string;
+    /**
+     * Kind of the def named by `origin`. May differ from `memberKind`: for a
+     * method inherited into a class from an interface, `memberKind` is `'class'`
+     * but `originKind` is `'interface'`. Pair with `origin` to build the
+     * declaring def's ref without re-resolving by name.
+     */
+    readonly originKind: 'class' | 'interface';
+    /** True if declared directly on the keyed def (own/override); false if purely inherited. */
+    readonly isOwn: boolean;
+    /** True if this method overrides a parent's default method */
+    readonly isOverride: boolean;
+    /**
+     * True if this class declares an own method that shadows a parent's sealed
+     * method. Always a sealed-contract violation — binding must reject it.
+     */
+    readonly shadowsSealed: boolean;
+    /** Namespace of the def this entry is keyed under in `DomainMethodsMap`. */
+    readonly memberKind: 'class' | 'interface';
+    /**
+     * Namespaced ref under the outer def (`{class|interface}.Owner.method.name`).
+     * For inherited methods, this is the position in `DomainMethodsMap`, NOT the
+     * materialization site — the actual Function node lives under the originating def.
+     */
+    readonly ref: string;
+    /**
+     * Absolute method path under the outer def. For own/override methods this
+     * matches `paths.absolute[ref]` (the materialized Function node). For inherited
+     * (`inherited-default`, `sealed`, `abstract`) entries this is a structural
+     * address only — no Function node is materialized at this path; the runtime
+     * dispatches through the originating def.
+     */
+    readonly path: MethodPath;
+}
+/**
+ * defRef (`class.X` / `interface.X`) → methodName → ResolvedMethod. The full
+ * method map for a compiled domain. Keyed by the kind-qualified ref (NOT the
+ * bare name) so a class and an interface that share a name (e.g. `Function`)
+ * each get their own entry. Use {@link classMethods} / {@link interfaceMethods}
+ * to look up by bare name.
+ */
+export type DomainMethodsMap = Readonly<Record<string, Readonly<Record<string, ResolvedMethod>>>>;
+/** Resolved methods of a class, by bare name, from a (defRef-keyed) DomainMethodsMap. */
+export declare function classMethods(m: DomainMethodsMap, name: string): Readonly<Record<string, ResolvedMethod>> | undefined;
+/** Resolved methods of an interface, by bare name, from a (defRef-keyed) DomainMethodsMap. */
+export declare function interfaceMethods(m: DomainMethodsMap, name: string): Readonly<Record<string, ResolvedMethod>> | undefined;
+/** Resolved methods of a def, by bare name + kind, from a (defRef-keyed) DomainMethodsMap. */
+export declare function methodsOf(m: DomainMethodsMap, kind: KindSegment, name: string): Readonly<Record<string, ResolvedMethod>> | undefined;
+/** A method resolved with builder-level origin and override information. */
+export interface MethodWithOrigin {
+    readonly fnDef: FnDef;
+    readonly inheritance: MethodInheritance;
+    /** Bare name of the def that declared this method. */
+    readonly origin: string;
+    /** Kind of the def named by `origin`. */
+    readonly originKind: KindSegment;
+    /** True if declared directly on the resolved def (own/override); false if purely inherited. */
+    readonly isOwn: boolean;
+    readonly isOverride: boolean;
+    /** True when own declaration shadows a sealed method inherited from a parent. */
+    readonly shadowsSealed: boolean;
+}
+/**
+ * Class names that have at least one own method.
+ * Used to constrain handler maps (only classes with methods need handler entries).
+ */
+export type MethodClassKeys<S extends Schema> = {
+    [K in ClassDefNames<S>]: keyof ExtractMethods<S['classes'][K]> extends never ? never : K;
+}[ClassDefNames<S>];
+/**
+ * Interface names that have at least one implementable own method.
+ * Used by runtime method handler typing.
+ */
+export type InterfaceMethodKeys<S extends Schema> = {
+    [K in InterfaceDefNames<S>]: keyof ExtractMethods<S['interfaces'][K]> extends never ? never : K;
+}[InterfaceDefNames<S>];
+/** Re-export for convenience — modules that resolve methods need this. */
+export type { DefDescriptor };
+//# sourceMappingURL=types.d.ts.map

package/dist/domain/compile/method/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../domain/compile/method/types.ts"],"names":[],"mappings":"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"}

package/dist/domain/compile/method/types.js

@@ -0,0 +1,14 @@
+import { defRef } from '@astrale-os/kernel-dsl';
+/** Resolved methods of a class, by bare name, from a (defRef-keyed) DomainMethodsMap. */
+export function classMethods(m, name) {
+    return m[defRef('class', name)];
+}
+/** Resolved methods of an interface, by bare name, from a (defRef-keyed) DomainMethodsMap. */
+export function interfaceMethods(m, name) {
+    return m[defRef('interface', name)];
+}
+/** Resolved methods of a def, by bare name + kind, from a (defRef-keyed) DomainMethodsMap. */
+export function methodsOf(m, kind, name) {
+    return m[defRef(kind, name)];
+}
+//# sourceMappingURL=types.js.map

package/dist/domain/compile/method/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../domain/compile/method/types.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAsE/C,yFAAyF;AACzF,MAAM,UAAU,YAAY,CAC1B,CAAmB,EACnB,IAAY;IAEZ,OAAO,CAAC,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAA;AACjC,CAAC;AAED,8FAA8F;AAC9F,MAAM,UAAU,gBAAgB,CAC9B,CAAmB,EACnB,IAAY;IAEZ,OAAO,CAAC,CAAC,MAAM,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC,CAAA;AACrC,CAAC;AAED,8FAA8F;AAC9F,MAAM,UAAU,SAAS,CACvB,CAAmB,EACnB,IAAiB,EACjB,IAAY;IAEZ,OAAO,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAA;AAC9B,CAAC"}

package/dist/domain/compile/method/wire.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Method wire path construction and parsing.
+ *
+ * Owns the canonical format for addressing a method on a node instance
+ * via the path grammar. Consumers (kernel-client, shell, CLI) import
+ * these instead of hardcoding grammar tokens and edge names.
+ */
+import type { CoreTokens as CoreGrammar } from '#graph/nav';
+/**
+ * Build the wire path for calling a method on a node instance.
+ *
+ * @example
+ * ```ts
+ * methodWirePath(CORE_GRAMMAR, 'abc-123', 'get')
+ * // → '@abc-123~method_of(get)'
+ * ```
+ */
+export declare function methodWirePath(grammar: CoreGrammar, nodeId: string, methodName: string): string;
+/**
+ * Extract the method name from a method wire path.
+ *
+ * Returns the method name if the path is a method traversal, `undefined` otherwise.
+ * When `classHint` is provided, returns the canonical `Class.method` ref.
+ *
+ * @example
+ * ```ts
+ * parseMethodFromWirePath(CORE_GRAMMAR, '@abc-123~method_of(get)')
+ * // → 'get'
+ *
+ * parseMethodFromWirePath(CORE_GRAMMAR, '@abc-123~method_of(get)', 'Document')
+ * // → 'Document.get'
+ * ```
+ */
+export declare function parseMethodFromWirePath(grammar: CoreGrammar, wirePath: string, classHint?: string): string | undefined;
+//# sourceMappingURL=wire.d.ts.map

package/dist/domain/compile/method/wire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.d.ts","sourceRoot":"","sources":["../../../../domain/compile/method/wire.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,UAAU,IAAI,WAAW,EAAE,MAAM,YAAY,CAAA;AAI3D;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAE/F;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,GAAG,SAAS,CAapB"}

package/dist/domain/compile/method/wire.js

@@ -0,0 +1,50 @@
+/**
+ * Method wire path construction and parsing.
+ *
+ * Owns the canonical format for addressing a method on a node instance
+ * via the path grammar. Consumers (kernel-client, shell, CLI) import
+ * these instead of hardcoding grammar tokens and edge names.
+ */
+import { METHOD_OF } from '#domain/addressing/edges';
+/**
+ * Build the wire path for calling a method on a node instance.
+ *
+ * @example
+ * ```ts
+ * methodWirePath(CORE_GRAMMAR, 'abc-123', 'get')
+ * // → '@abc-123~method_of(get)'
+ * ```
+ */
+export function methodWirePath(grammar, nodeId, methodName) {
+    return `${grammar.idPrefix}${nodeId}${grammar.traversalOp}${METHOD_OF}${grammar.filterOpen}${methodName}${grammar.filterClose}`;
+}
+/**
+ * Extract the method name from a method wire path.
+ *
+ * Returns the method name if the path is a method traversal, `undefined` otherwise.
+ * When `classHint` is provided, returns the canonical `Class.method` ref.
+ *
+ * @example
+ * ```ts
+ * parseMethodFromWirePath(CORE_GRAMMAR, '@abc-123~method_of(get)')
+ * // → 'get'
+ *
+ * parseMethodFromWirePath(CORE_GRAMMAR, '@abc-123~method_of(get)', 'Document')
+ * // → 'Document.get'
+ * ```
+ */
+export function parseMethodFromWirePath(grammar, wirePath, classHint) {
+    const traversalMarker = `${grammar.traversalOp}${METHOD_OF}${grammar.filterOpen}`;
+    const idx = wirePath.indexOf(traversalMarker);
+    if (idx === -1)
+        return undefined;
+    const start = idx + traversalMarker.length;
+    const end = wirePath.indexOf(grammar.filterClose, start);
+    if (end === -1)
+        return undefined;
+    const methodName = wirePath.slice(start, end);
+    if (!methodName)
+        return undefined;
+    return classHint ? `${classHint}.${methodName}` : methodName;
+}
+//# sourceMappingURL=wire.js.map

package/dist/domain/compile/method/wire.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.js","sourceRoot":"","sources":["../../../../domain/compile/method/wire.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AAEpD;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAAC,OAAoB,EAAE,MAAc,EAAE,UAAkB;IACrF,OAAO,GAAG,OAAO,CAAC,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC,WAAW,EAAE,CAAA;AACjI,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,uBAAuB,CACrC,OAAoB,EACpB,QAAgB,EAChB,SAAkB;IAElB,MAAM,eAAe,GAAG,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC,UAAU,EAAE,CAAA;IACjF,MAAM,GAAG,GAAG,QAAQ,CAAC,OAAO,CAAC,eAAe,CAAC,CAAA;IAC7C,IAAI,GAAG,KAAK,CAAC,CAAC;QAAE,OAAO,SAAS,CAAA;IAEhC,MAAM,KAAK,GAAG,GAAG,GAAG,eAAe,CAAC,MAAM,CAAA;IAC1C,MAAM,GAAG,GAAG,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,WAAW,EAAE,KAAK,CAAC,CAAA;IACxD,IAAI,GAAG,KAAK,CAAC,CAAC;QAAE,OAAO,SAAS,CAAA;IAEhC,MAAM,UAAU,GAAG,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;IAC7C,IAAI,CAAC,UAAU;QAAE,OAAO,SAAS,CAAA;IAEjC,OAAO,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,IAAI,UAAU,EAAE,CAAC,CAAC,CAAC,UAAU,CAAA;AAC9D,CAAC"}

package/dist/domain/compile/property/build.d.ts

@@ -0,0 +1,20 @@
+import type { Schema } from '@astrale-os/kernel-dsl';
+import type { DomainImportsMap } from '#domain/compile/imports/types';
+import type { DomainPropertyIndex } from './types';
+/**
+ * Build the complete property mapping index for a schema.
+ *
+ * For each concrete class (node or edge), walks the full inheritance tree and
+ * collects all properties (own + inherited). Each property is mapped to its
+ * globally unique key using the declaring type's domain and namespace.
+ *
+ * Class-own properties are marked as attributes (isAttribute: true).
+ * Interface-inherited properties are marked as non-attributes.
+ * The private flag comes from the PropertyDef metadata.
+ *
+ * @param schema - The schema to analyze
+ * @param imports - Resolved import map (type name → domain origin)
+ * @returns Immutable DomainPropertyIndex
+ */
+export declare function buildPropertyMappings(schema: Schema, imports: DomainImportsMap): DomainPropertyIndex;
+//# sourceMappingURL=build.d.ts.map

package/dist/domain/compile/property/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../../domain/compile/property/build.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAyB,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAU3E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAMrE,OAAO,KAAK,EAAmB,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAEnE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,gBAAgB,GACxB,mBAAmB,CA+CrB"}

package/dist/domain/compile/property/build.js

@@ -0,0 +1,90 @@
+import { buildDefDescriptorMap, normalizeProperty, } from '@astrale-os/kernel-dsl';
+import { Key } from '#domain/addressing/keys/key';
+import { Ref } from '#domain/addressing/refs/ref';
+/**
+ * Build the complete property mapping index for a schema.
+ *
+ * For each concrete class (node or edge), walks the full inheritance tree and
+ * collects all properties (own + inherited). Each property is mapped to its
+ * globally unique key using the declaring type's domain and namespace.
+ *
+ * Class-own properties are marked as attributes (isAttribute: true).
+ * Interface-inherited properties are marked as non-attributes.
+ * The private flag comes from the PropertyDef metadata.
+ *
+ * @param schema - The schema to analyze
+ * @param imports - Resolved import map (type name → domain origin)
+ * @returns Immutable DomainPropertyIndex
+ */
+export function buildPropertyMappings(schema, imports) {
+    const byClass = {};
+    const flat = {};
+    const memberIndex = new Map();
+    const localDomain = schema.domain;
+    const descriptorMap = buildDefDescriptorMap(schema);
+    // Only iterate concrete classes (skip interfaces — they're collected via inheritance walking)
+    for (const [name, def] of Object.entries(schema.classes)) {
+        const classEntry = {};
+        const flatEntry = {};
+        // 1. Collect own properties (attributes)
+        const ownProps = def.config.properties;
+        if (ownProps) {
+            collectProps(classEntry, flatEntry, memberIndex, ownProps, name, localDomain, 'class', true);
+        }
+        // 2. Walk inheritance tree for interface properties
+        const visited = new WeakSet();
+        visited.add(def);
+        collectInheritedProps(classEntry, flatEntry, memberIndex, def, localDomain, imports, visited, descriptorMap);
+        byClass[name] = classEntry;
+        flat[name] = flatEntry;
+    }
+    return Object.freeze({
+        byClass: Object.freeze(byClass),
+        flat: Object.freeze(flat),
+        resolveMember(key) {
+            return memberIndex.get(key);
+        },
+    });
+}
+function collectProps(byDomainOwner, flatOut, memberIndex, props, ownerName, ownerDomain, ownerNamespace, isAttribute) {
+    if (!byDomainOwner[ownerDomain])
+        byDomainOwner[ownerDomain] = {};
+    if (!byDomainOwner[ownerDomain][ownerName])
+        byDomainOwner[ownerDomain][ownerName] = {};
+    for (const [propName, propDef] of Object.entries(props)) {
+        const normalized = normalizeProperty(propDef);
+        const key = Key.of(ownerDomain, Ref.property(ownerNamespace, ownerName, propName)).toString();
+        const mapping = Object.freeze({
+            key,
+            propName,
+            owner: ownerName,
+            domain: ownerDomain,
+            private: normalized.private,
+            isAttribute,
+            required: normalized.required,
+        });
+        byDomainOwner[ownerDomain][ownerName][propName] = mapping;
+        flatOut[propName] = mapping;
+        memberIndex.set(key, mapping);
+    }
+}
+function collectInheritedProps(byDomainOwner, flatOut, memberIndex, def, localDomain, imports, visited, descriptorMap) {
+    const inherits = def.config.inherits ?? [];
+    for (const parent of inherits) {
+        if (visited.has(parent))
+            continue;
+        visited.add(parent);
+        const descriptor = descriptorMap.get(parent);
+        if (!descriptor)
+            continue;
+        const parentDomain = imports[descriptor.name] ?? localDomain;
+        // Inherited types are always interfaces (classes don't inherit from other classes via inherits)
+        const parentNamespace = 'interface';
+        const parentProps = parent.config.properties;
+        if (parentProps) {
+            collectProps(byDomainOwner, flatOut, memberIndex, parentProps, descriptor.name, parentDomain, parentNamespace, false);
+        }
+        collectInheritedProps(byDomainOwner, flatOut, memberIndex, parent, localDomain, imports, visited, descriptorMap);
+    }
+}
+//# sourceMappingURL=build.js.map

package/dist/domain/compile/property/build.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.js","sourceRoot":"","sources":["../../../../domain/compile/property/build.ts"],"names":[],"mappings":"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"}

package/dist/domain/compile/property/index.d.ts

@@ -0,0 +1,3 @@
+export type { PropertyMapping, DomainPropertyIndex } from './types';
+export { buildPropertyMappings } from './build';
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/compile/property/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../domain/compile/property/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AACnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA"}

package/dist/domain/compile/property/index.js

@@ -0,0 +1,2 @@
+export { buildPropertyMappings } from './build';
+//# sourceMappingURL=index.js.map

package/dist/domain/compile/property/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../domain/compile/property/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA"}

package/dist/domain/compile/property/types.d.ts

@@ -0,0 +1,84 @@
+import type { DomainKey } from '#domain/addressing/keys/types';
+import type { DomainOrigin } from '#domain/origin';
+/**
+ * Describes a single property's identity, ownership, and access control.
+ * Computed at compilation time. Immutable.
+ */
+export interface PropertyMapping {
+    /** Full globally unique key: 'blog.acme.com:class.Author.property.bio' */
+    readonly key: DomainKey;
+    /** Bare property name: 'bio' */
+    readonly propName: string;
+    /** Declaring type name: 'Author' (the class or interface that defined this property) */
+    readonly owner: string;
+    /** Domain origin of the declaring type: 'blog.acme.com' */
+    readonly domain: DomainOrigin;
+    /** If true, writes require permission */
+    readonly private: boolean;
+    /** If true, this is a class-own attribute (not inherited from an interface) */
+    readonly isAttribute: boolean;
+    /**
+     * If true, the property MUST be provided when creating a node of this
+     * class. Computed from the underlying zod schema: `.optional()` and
+     * `.default(...)` mark a prop as not required; `.nullable()` does not
+     * (a nullable prop must still be provided, even if as `null`).
+     */
+    readonly required: boolean;
+}
+/**
+ * Index of all property mappings for a compiled domain.
+ * Provides three access patterns:
+ * - `byClass` for full enumeration with no-shadowing guarantee, keyed by
+ *   (className, domain, owner, propName) so cross-domain interfaces with
+ *   the same local name coexist independently.
+ * - `flat` for simple access when no name collisions
+ * - `resolveMember` for point lookups via member key
+ */
+export interface DomainPropertyIndex {
+    /**
+     * className → ownerDomain → ownerName → propName → PropertyMapping.
+     *
+     * Four-level nesting because the (domain, owner) pair is what truly
+     * disambiguates an inherited property — two domains can both export an
+     * interface named `Named`, and a class inheriting both must address
+     * each independently.
+     *
+     * - Outer key: the CLASS that has this property (e.g., 'Author')
+     * - Domain:  the DOMAIN that declares the owner (e.g., 'kernel.astrale.ai')
+     * - Owner:   the OWNER definition name (e.g., 'Named', 'Author')
+     * - Prop:    the property name (e.g., 'name', 'bio')
+     *
+     * @example
+     *   // Interface-inherited property
+     *   index.byClass['Author']['kernel.astrale.ai']['Named']['name']
+     *   // → { key: 'kernel.astrale.ai:interface.Named.property.name', owner: 'Named', isAttribute: false }
+     *
+     *   // Class-own attribute (owner = own class, domain = own domain)
+     *   index.byClass['Author']['blog.acme.com']['Author']['bio']
+     *   // → { key: 'blog.acme.com:class.Author.property.bio', owner: 'Author', isAttribute: true }
+     */
+    readonly byClass: Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, PropertyMapping>>>>>>>>;
+    /**
+     * Flat view: className → propName → PropertyMapping.
+     * Convenience accessor when there are no same-name collisions.
+     * If two owners define a property with the same name, the LAST one
+     * traversed wins (deterministic but arbitrary). Use `byClass` for
+     * unambiguous access.
+     *
+     * @example
+     *   index.flat['Author']['bio']   // PropertyMapping (unambiguous)
+     *   index.flat['Author']['name']  // PropertyMapping (from Named — or whichever interface was last)
+     */
+    readonly flat: Readonly<Record<string, Readonly<Record<string, PropertyMapping>>>>;
+    /**
+     * Resolve a property key to its PropertyMapping.
+     * Accepts property keys: `domain:namespace.Owner.property.propName`.
+     * Returns undefined for non-property keys, malformed keys, or unknown keys.
+     *
+     * @example
+     *   index.resolveMember('blog.acme.com:class.Author.property.bio')  // PropertyMapping
+     *   index.resolveMember('blog.acme.com:class.Author')               // undefined (member key)
+     */
+    resolveMember(key: string): PropertyMapping | undefined;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/domain/compile/property/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../domain/compile/property/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAA;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAElD;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,0EAA0E;IAC1E,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAA;IACvB,gCAAgC;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,wFAAwF;IACxF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,2DAA2D;IAC3D,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;IAC7B,yCAAyC;IACzC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,+EAA+E;IAC/E,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAC3B;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,QAAQ,CAAC,OAAO,EAAE,QAAQ,CACxB,MAAM,CACJ,MAAM,EACN,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAC9F,CACF,CAAA;IAED;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAA;IAElF;;;;;;;;OAQG;IACH,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAAA;CACxD"}

package/dist/domain/compile/property/types.js

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

package/dist/domain/compile/property/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../domain/compile/property/types.ts"],"names":[],"mappings":""}

package/dist/domain/compile/types.d.ts

@@ -0,0 +1,56 @@
+import type { Schema } from '@astrale-os/kernel-dsl';
+import type { ClassPath } from '#domain';
+import type { FlatRefs } from '#domain/addressing/refs/types';
+import type { DomainInternals } from './internals';
+/** Flat ref → ClassPath mapping (only member refs, not methods or core). */
+export type ClassPathMap = {
+    readonly [ref: string]: ClassPath;
+};
+/**
+ * A fully compiled domain — the central abstraction of the domain system.
+ *
+ * The top-level surface has a single reserved key: `$`. Everything else is a
+ * schema member (flat class/interface access via spread-in `DomainRefs`).
+ * Engine metadata, accessors, and derivations all live under `$`.
+ *
+ * @example
+ * ```ts
+ * const blog = compileDomain(BlogSchema)
+ *
+ * // Flat schema members
+ * blog.Author.ref                    // 'class.Author'
+ * blog.Author.key                    // 'blog.acme.com:class.Author'
+ * blog.Author.path.class             // ClassPath
+ * blog.Author.describe.path.method   // MethodPath
+ * blog.Author.bio.key                // property key
+ *
+ * // Engine metadata under the $ sigil
+ * blog.$.origin                      // DomainOrigin
+ * blog.$.refs                        // structured refs
+ * blog.$.methods                     // resolved methods (incl. inherited)
+ * blog.$.properties                  // property key index
+ * blog.$.c('Author').key             // disambiguation
+ * blog.$.group('Author', flat)       // shape a flat record
+ * ```
+ */
+export interface CompiledDomain<S extends Schema = Schema> {
+    /** Engine metadata and tools — the only reserved name at the top level. */
+    readonly $: DomainInternals<S>;
+}
+/**
+ * CompiledDomain with flat ref shortcuts at the top level.
+ *
+ * Returned by `compileDomain()`. Spreads `refs.classes` and `refs.interfaces`
+ * so every schema member is directly accessible.
+ *
+ * Named type avoids TS7056 — the inferred intersection of CompiledDomain +
+ * N RefEntry-with-MethodRefs would exceed the serialization limit if expanded.
+ *
+ * Flat members come from `FlatRefs` (not a raw `classes & interfaces`
+ * intersection). A class/interface homonym (`Function`) is NOT flattened: it
+ * maps to an `AmbiguousMember` marker so `K.Function` fails to type-check and
+ * forces explicit `K.$.c('Function')` / `K.$.i('Function')`, instead of
+ * silently winning to the interface or collapsing to `never`.
+ */
+export type Domain<S extends Schema = Schema> = CompiledDomain<S> & FlatRefs<S>;
+//# sourceMappingURL=types.d.ts.map

package/dist/domain/compile/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../domain/compile/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAEpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACxC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAA;AAE7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAElD,4EAA4E;AAC5E,MAAM,MAAM,YAAY,GAAG;IAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAA;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IACvD,2EAA2E;IAC3E,QAAQ,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAA;CAC/B;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI,cAAc,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAA"}

package/dist/domain/compile/types.js

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

package/dist/domain/compile/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../domain/compile/types.ts"],"names":[],"mappings":""}

package/dist/domain/compile/validation/index.d.ts

@@ -0,0 +1,3 @@
+export type { ValidationWarning } from './validate';
+export { validateDomain } from './validate';
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/compile/validation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../domain/compile/validation/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA"}

package/dist/domain/compile/validation/index.js

@@ -0,0 +1,2 @@
+export { validateDomain } from './validate';
+//# sourceMappingURL=index.js.map

package/dist/domain/compile/validation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../domain/compile/validation/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA"}

package/dist/domain/compile/validation/validate.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Build-time validation for domain schemas.
+ *
+ * Called from compileDomain() to surface:
+ * - Interface name collisions (warning) — same-named interfaces from different domains
+ * - Reserved structural field names (error) — id, slug, class, attrs, $d, etc.
+ * - Flat-spread shadowing (warning) — class vs interface names, property vs method names,
+ *   schema names that shadow CompiledDomain fields, property names that shadow entry fields.
+ */
+import type { Schema } from '@astrale-os/kernel-dsl';
+import type { DomainMethodsMap } from '#domain/compile/method/types';
+import type { DomainPropertyIndex } from '#domain/compile/property/types';
+import type { DomainOrigin } from '#domain/origin';
+export interface ValidationWarning {
+    readonly code: string;
+    readonly message: string;
+    readonly context?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Validate a compiled domain's property index and method map.
+ *
+ * Throws CompilationError for hard errors (reserved names).
+ * Returns a list of warnings for soft issues (interface/method name collisions).
+ */
+export declare function validateDomain(origin: DomainOrigin, propertyIndex: DomainPropertyIndex, schema: Schema, methods: DomainMethodsMap): ValidationWarning[];
+//# sourceMappingURL=validate.d.ts.map

package/dist/domain/compile/validation/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../../domain/compile/validation/validate.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAsC,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAIxF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAA;AACpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAA;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAmBlD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CACrD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,YAAY,EACpB,aAAa,EAAE,mBAAmB,EAClC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,gBAAgB,GACxB,iBAAiB,EAAE,CAwErB"}