@astrale-os/kernel-core 0.4.1

package/dist/domain/addressing/refs/types.js

@@ -0,0 +1,27 @@
+/**
+ * Domain ref types — structured, group-prefixed identifiers for domain items.
+ *
+ * Each ref entry carries three identity axes:
+ *   - `ref`  — what it is ('class.Author', 'interface.Named.method.format')
+ *   - `key`  — who owns it ('blog.acme.com:class.Author')
+ *   - `path` — where it is (domain: semantic, absolute: tree position, class: type identity)
+ *
+ * Access pattern:
+ *   refs.classes.Author.ref                  → 'class.Author'
+ *   refs.classes.Author.key                  → 'blog.acme.com:class.Author'
+ *   refs.classes.Author.path.domain          → DomainPath
+ *   refs.classes.Author.path.absolute        → AbsolutePath
+ *   refs.classes.Author.path.class           → ClassPath
+ *   refs.classes.Author.describe.ref         → 'class.Author.method.describe'
+ *   refs.classes.Author.describe.path.method → MethodPath
+ *   refs.classes.Author.bio.ref              → 'class.Author.property.bio'
+ *   refs.classes.Author.bio.key              → 'blog.acme.com:class.Author.property.bio'
+ *   refs.interfaces.Named.ref                → 'interface.Named'
+ *   refs.core.alice.ref                      → 'core.alice'
+ *
+ * Disambiguation accessors (always available, bypass flat-spread shadowing):
+ *   refs.classes.Author.$.m('describe')      → MethodRefEntry
+ *   refs.classes.Author.$.p('bio')           → PropertyRefEntry
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/domain/addressing/refs/types.js.map

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

package/dist/domain/addressing/segments/installed-in.d.ts

@@ -0,0 +1,15 @@
+import type { SingleHop } from '#graph/nav/scheme';
+/**
+ * The installed-in scheme segment.
+ *
+ * Single hop on `installed_in` (inbound in IR). The Domain is the
+ * source of the edge and its mount is the target; the generic walker
+ * goes outgoing from the domain and lands at the mount, which becomes
+ * the predecessor for the next outer segment (typically the absolute
+ * tree segment).
+ *
+ * Cardinality contract (enforced schema-side): every Domain has
+ * exactly one outgoing `installed_in` edge.
+ */
+export declare const installedInSegment: SingleHop;
+//# sourceMappingURL=installed-in.d.ts.map

package/dist/domain/addressing/segments/installed-in.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installed-in.d.ts","sourceRoot":"","sources":["../../../../domain/addressing/segments/installed-in.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAIlD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAIhC,CAAA"}

package/dist/domain/addressing/segments/installed-in.js

@@ -0,0 +1,19 @@
+import { INSTALLED_IN } from '../edges';
+/**
+ * The installed-in scheme segment.
+ *
+ * Single hop on `installed_in` (inbound in IR). The Domain is the
+ * source of the edge and its mount is the target; the generic walker
+ * goes outgoing from the domain and lands at the mount, which becomes
+ * the predecessor for the next outer segment (typically the absolute
+ * tree segment).
+ *
+ * Cardinality contract (enforced schema-side): every Domain has
+ * exactly one outgoing `installed_in` edge.
+ */
+export const installedInSegment = {
+    kind: 'single',
+    name: 'installed-in',
+    hop: { edge: INSTALLED_IN, direction: 'inbound' },
+};
+//# sourceMappingURL=installed-in.js.map

package/dist/domain/addressing/segments/installed-in.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"installed-in.js","sourceRoot":"","sources":["../../../../domain/addressing/segments/installed-in.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAEvC;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAc;IAC3C,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,cAAc;IACpB,GAAG,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE;CAClD,CAAA"}

package/dist/domain/addressing/segments/method-of.d.ts

@@ -0,0 +1,10 @@
+import type { SingleHop } from '#graph/nav/scheme';
+/**
+ * The method-of scheme segment.
+ *
+ * Single hop on `method_of` (inbound in IR). A Function node (method)'s
+ * outgoing `method_of` edge points to its owning class or
+ * interface; the generic walker lands at the owner.
+ */
+export declare const methodOfSegment: SingleHop;
+//# sourceMappingURL=method-of.d.ts.map

package/dist/domain/addressing/segments/method-of.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"method-of.d.ts","sourceRoot":"","sources":["../../../../domain/addressing/segments/method-of.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAIlD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,EAAE,SAI7B,CAAA"}

package/dist/domain/addressing/segments/method-of.js

@@ -0,0 +1,14 @@
+import { METHOD_OF } from '../edges';
+/**
+ * The method-of scheme segment.
+ *
+ * Single hop on `method_of` (inbound in IR). A Function node (method)'s
+ * outgoing `method_of` edge points to its owning class or
+ * interface; the generic walker lands at the owner.
+ */
+export const methodOfSegment = {
+    kind: 'single',
+    name: 'method-of',
+    hop: { edge: METHOD_OF, direction: 'inbound' },
+};
+//# sourceMappingURL=method-of.js.map

package/dist/domain/addressing/segments/method-of.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"method-of.js","sourceRoot":"","sources":["../../../../domain/addressing/segments/method-of.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEpC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAc;IACxC,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,WAAW;IACjB,GAAG,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE;CAC/C,CAAA"}

package/dist/domain/addressing/segments/of-domain.d.ts

@@ -0,0 +1,15 @@
+import type { SingleHop } from '#graph/nav/scheme';
+/**
+ * The of-domain scheme segment.
+ *
+ * Single hop on `of_domain` (inbound in IR). A Class/Interface
+ * member's outgoing `of_domain` edge points to its owning Domain;
+ * the generic walker lands at the domain, which becomes the
+ * predecessor for the next outer segment.
+ *
+ * Cardinality contract (schema-side): every Class/Interface has
+ * exactly one outgoing `of_domain` edge. The slug discriminates kind
+ * (`class.X` / `interface.X`) — checked at the type layer, not here.
+ */
+export declare const ofDomainSegment: SingleHop;
+//# sourceMappingURL=of-domain.d.ts.map

package/dist/domain/addressing/segments/of-domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"of-domain.d.ts","sourceRoot":"","sources":["../../../../domain/addressing/segments/of-domain.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAIlD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,EAAE,SAI7B,CAAA"}

package/dist/domain/addressing/segments/of-domain.js

@@ -0,0 +1,19 @@
+import { OF_DOMAIN } from '../edges';
+/**
+ * The of-domain scheme segment.
+ *
+ * Single hop on `of_domain` (inbound in IR). A Class/Interface
+ * member's outgoing `of_domain` edge points to its owning Domain;
+ * the generic walker lands at the domain, which becomes the
+ * predecessor for the next outer segment.
+ *
+ * Cardinality contract (schema-side): every Class/Interface has
+ * exactly one outgoing `of_domain` edge. The slug discriminates kind
+ * (`class.X` / `interface.X`) — checked at the type layer, not here.
+ */
+export const ofDomainSegment = {
+    kind: 'single',
+    name: 'of-domain',
+    hop: { edge: OF_DOMAIN, direction: 'inbound' },
+};
+//# sourceMappingURL=of-domain.js.map

package/dist/domain/addressing/segments/of-domain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"of-domain.js","sourceRoot":"","sources":["../../../../domain/addressing/segments/of-domain.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEpC;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,eAAe,GAAc;IACxC,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,WAAW;IACjB,GAAG,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE;CAC/C,CAAA"}

package/dist/domain/compile/catalog/def-types.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Type-level utilities for schema definition names.
+ *
+ * Provides typed access to definition names across the 2-group schema format.
+ * Used by method typing, CompiledDomain, and instance typing.
+ */
+import type { Schema } from '@astrale-os/kernel-dsl';
+/** All definition names from a schema (both interfaces and classes). */
+export type AllDefNames<S extends Schema> = (keyof S['interfaces'] & string) | (keyof S['classes'] & string);
+/**
+ * Look up a CLASS definition by name. Resolution is kind-explicit: there is no
+ * bare-name lookup that merges the two groups, so a class/interface homonym
+ * (`Function`) can never accidentally resolve to the interface and leak its
+ * methods (e.g. the interface's `list`) into the class. Use the matching
+ * `DefForInterface` for the interface side.
+ */
+export type DefForClass<S extends Schema, K extends string> = K extends keyof S['classes'] ? S['classes'][K] : never;
+/**
+ * Look up an INTERFACE definition by name — the mirror of `DefForClass` for the
+ * interface side of a class/interface homonym (`Function`). Returns `never` for a
+ * class-only name, so it can never fall back to a class.
+ */
+export type DefForInterface<S extends Schema, K extends string> = K extends keyof S['interfaces'] ? S['interfaces'][K] : never;
+/** Class-only definition names. */
+export type ClassDefNames<S extends Schema> = keyof S['classes'] & string;
+/** Interface definition names. */
+export type InterfaceDefNames<S extends Schema> = keyof S['interfaces'] & string;
+//# sourceMappingURL=def-types.d.ts.map

package/dist/domain/compile/catalog/def-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"def-types.d.ts","sourceRoot":"","sources":["../../../../domain/compile/catalog/def-types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAEpD,wEAAwE;AACxE,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,MAAM,IACpC,CAAC,MAAM,CAAC,CAAC,YAAY,CAAC,GAAG,MAAM,CAAC,GAChC,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,GAAG,MAAM,CAAC,CAAA;AAEjC;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,MAAM,CAAC,CAAC,SAAS,CAAC,GACtF,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GACf,KAAK,CAAA;AAET;;;;GAIG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,MAAM,CAAC,CAAC,YAAY,CAAC,GAC7F,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GAClB,KAAK,CAAA;AAET,mCAAmC;AACnC,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,MAAM,IAAI,MAAM,CAAC,CAAC,SAAS,CAAC,GAAG,MAAM,CAAA;AAEzE,kCAAkC;AAClC,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,MAAM,IAAI,MAAM,CAAC,CAAC,YAAY,CAAC,GAAG,MAAM,CAAA"}

package/dist/domain/compile/catalog/def-types.js

@@ -0,0 +1,8 @@
+/**
+ * Type-level utilities for schema definition names.
+ *
+ * Provides typed access to definition names across the 2-group schema format.
+ * Used by method typing, CompiledDomain, and instance typing.
+ */
+export {};
+//# sourceMappingURL=def-types.js.map

package/dist/domain/compile/catalog/def-types.js.map

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

package/dist/domain/compile/catalog/defs.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Schema def catalog — iteration helpers.
+ */
+import type { AnyDef, Schema } from '@astrale-os/kernel-dsl';
+/** Iterate all definitions from both groups, yielding [name, def] pairs. */
+export declare function allDefs(schema: Schema): [string, AnyDef][];
+//# sourceMappingURL=defs.d.ts.map

package/dist/domain/compile/catalog/defs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defs.d.ts","sourceRoot":"","sources":["../../../../domain/compile/catalog/defs.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAE5D,4EAA4E;AAC5E,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAK1D"}

package/dist/domain/compile/catalog/defs.js

@@ -0,0 +1,8 @@
+/**
+ * Schema def catalog — iteration helpers.
+ */
+/** Iterate all definitions from both groups, yielding [name, def] pairs. */
+export function allDefs(schema) {
+    return [...Object.entries(schema.interfaces), ...Object.entries(schema.classes)];
+}
+//# sourceMappingURL=defs.js.map

package/dist/domain/compile/catalog/defs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defs.js","sourceRoot":"","sources":["../../../../domain/compile/catalog/defs.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,4EAA4E;AAC5E,MAAM,UAAU,OAAO,CAAC,MAAc;IACpC,OAAO,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAG5E,CAAA;AACL,CAAC"}

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

@@ -0,0 +1,4 @@
+export { allDefs } from './defs';
+export type { AllDefNames, ClassDefNames, DefForClass, DefForInterface, InterfaceDefNames, } from './def-types';
+export { KERNEL_INTERFACE_NAMES, RESERVED_NODE_FIELDS, SYSTEM_PROPERTY_MAP, } from './system-properties';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../domain/compile/catalog/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAGhC,YAAY,EACV,WAAW,EACX,aAAa,EACb,WAAW,EACX,eAAe,EACf,iBAAiB,GAClB,MAAM,aAAa,CAAA;AAGpB,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,qBAAqB,CAAA"}

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

@@ -0,0 +1,5 @@
+// ── Def iteration & classification ────────────────────────────────────
+export { allDefs } from './defs';
+// ── System properties & reserved names ───────────────────────────────
+export { KERNEL_INTERFACE_NAMES, RESERVED_NODE_FIELDS, SYSTEM_PROPERTY_MAP, } from './system-properties';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../domain/compile/catalog/index.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAWhC,wEAAwE;AACxE,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,qBAAqB,CAAA"}

package/dist/domain/compile/catalog/system-properties.d.ts

@@ -0,0 +1,28 @@
+/**
+ * SYSTEM_PROPERTY_MAP — reserved property names from kernel interfaces.
+ *
+ * Used for build-time validation: warns when a user-defined interface name
+ * collides with a kernel interface. Also lists reserved structural field names
+ * that cannot be used as interface/class names.
+ */
+import type { DomainOrigin } from '#domain/origin';
+/**
+ * Kernel interface names that define properties.
+ * These are the names that will appear as sugar accessors on nodes
+ * (e.g., node.Named.name, node.Timestamped.createdAt).
+ *
+ * User schemas can define interfaces with the same name — but it triggers
+ * a build-time warning and requires $d() access at runtime.
+ */
+export declare const KERNEL_INTERFACE_NAMES: readonly ['Named', 'Sluggable', 'Timestamped', 'Remotable', 'Descriptable', 'Iconable', 'Statused', 'Node', 'Edge', 'Container', 'Identity', 'Function'];
+/**
+ * Reserved structural field names that cannot be used as interface or class names.
+ * These are used by the Node object structure itself.
+ */
+export declare const RESERVED_NODE_FIELDS: readonly ['id', 'slug', 'class', 'path', '__labels', 'remote', 'classId', 'attrs', '$d'];
+/**
+ * System property map: interfaceName → propName → domain origin.
+ * Records which kernel interfaces define which properties.
+ */
+export declare const SYSTEM_PROPERTY_MAP: Readonly<Record<string, Readonly<Record<string, DomainOrigin>>>>;
+//# sourceMappingURL=system-properties.d.ts.map

package/dist/domain/compile/catalog/system-properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-properties.d.ts","sourceRoot":"","sources":["../../../../domain/compile/catalog/system-properties.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAIlD;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,YACjC,OAAO,EACP,WAAW,EACX,aAAa,EACb,WAAW,EACX,cAAc,EACd,UAAU,EACV,UAAU,EACV,MAAM,EACN,MAAM,EACN,WAAW,EACX,UAAU,EACV,UAAU,CACF,CAAA;AAEV;;;GAGG;AACH,eAAO,MAAM,oBAAoB,YAC/B,IAAI,EACJ,MAAM,EACN,OAAO,EACP,MAAM,EACN,UAAU,EACV,QAAQ,EACR,SAAS,EACT,OAAO,EACP,IAAI,CACI,CAAA;AAEV;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,CAqB9F,CAAA"}

package/dist/domain/compile/catalog/system-properties.js

@@ -0,0 +1,71 @@
+/**
+ * SYSTEM_PROPERTY_MAP — reserved property names from kernel interfaces.
+ *
+ * Used for build-time validation: warns when a user-defined interface name
+ * collides with a kernel interface. Also lists reserved structural field names
+ * that cannot be used as interface/class names.
+ */
+const KERNEL_ORIGIN = 'kernel.astrale.ai';
+/**
+ * Kernel interface names that define properties.
+ * These are the names that will appear as sugar accessors on nodes
+ * (e.g., node.Named.name, node.Timestamped.createdAt).
+ *
+ * User schemas can define interfaces with the same name — but it triggers
+ * a build-time warning and requires $d() access at runtime.
+ */
+export const KERNEL_INTERFACE_NAMES = [
+    'Named',
+    'Sluggable',
+    'Timestamped',
+    'Remotable',
+    'Descriptable',
+    'Iconable',
+    'Statused',
+    'Node',
+    'Edge',
+    'Container',
+    'Identity',
+    'Function',
+];
+/**
+ * Reserved structural field names that cannot be used as interface or class names.
+ * These are used by the Node object structure itself.
+ */
+export const RESERVED_NODE_FIELDS = [
+    'id',
+    'slug',
+    'class',
+    'path',
+    '__labels',
+    'remote',
+    'classId',
+    'attrs',
+    '$d',
+];
+/**
+ * System property map: interfaceName → propName → domain origin.
+ * Records which kernel interfaces define which properties.
+ */
+export const SYSTEM_PROPERTY_MAP = {
+    Named: { name: KERNEL_ORIGIN },
+    Sluggable: { slug: KERNEL_ORIGIN },
+    Timestamped: { createdAt: KERNEL_ORIGIN, updatedAt: KERNEL_ORIGIN },
+    Remotable: { url: KERNEL_ORIGIN, protocol: KERNEL_ORIGIN },
+    Descriptable: { description: KERNEL_ORIGIN },
+    Iconable: { icon: KERNEL_ORIGIN },
+    Statused: { status: KERNEL_ORIGIN },
+    Identity: {
+        publicKey: KERNEL_ORIGIN,
+        requiredClaims: KERNEL_ORIGIN,
+        claimConstraints: KERNEL_ORIGIN,
+    },
+    Function: {
+        inputSchema: KERNEL_ORIGIN,
+        outputSchema: KERNEL_ORIGIN,
+        code: KERNEL_ORIGIN,
+        isStatic: KERNEL_ORIGIN,
+        output: KERNEL_ORIGIN,
+    },
+};
+//# sourceMappingURL=system-properties.js.map

package/dist/domain/compile/catalog/system-properties.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-properties.js","sourceRoot":"","sources":["../../../../domain/compile/catalog/system-properties.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,MAAM,aAAa,GAAG,mBAAmC,CAAA;AAEzD;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,OAAO;IACP,WAAW;IACX,aAAa;IACb,WAAW;IACX,cAAc;IACd,UAAU;IACV,UAAU;IACV,MAAM;IACN,MAAM;IACN,WAAW;IACX,UAAU;IACV,UAAU;CACF,CAAA;AAEV;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,IAAI;IACJ,MAAM;IACN,OAAO;IACP,MAAM;IACN,UAAU;IACV,QAAQ;IACR,SAAS;IACT,OAAO;IACP,IAAI;CACI,CAAA;AAEV;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAC9B;IACE,KAAK,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE;IAC9B,SAAS,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE;IAClC,WAAW,EAAE,EAAE,SAAS,EAAE,aAAa,EAAE,SAAS,EAAE,aAAa,EAAE;IACnE,SAAS,EAAE,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,EAAE,aAAa,EAAE;IAC1D,YAAY,EAAE,EAAE,WAAW,EAAE,aAAa,EAAE;IAC5C,QAAQ,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE;IACjC,QAAQ,EAAE,EAAE,MAAM,EAAE,aAAa,EAAE;IACnC,QAAQ,EAAE;QACR,SAAS,EAAE,aAAa;QACxB,cAAc,EAAE,aAAa;QAC7B,gBAAgB,EAAE,aAAa;KAChC;IACD,QAAQ,EAAE;QACR,WAAW,EAAE,aAAa;QAC1B,YAAY,EAAE,aAAa;QAC3B,IAAI,EAAE,aAAa;QACnB,QAAQ,EAAE,aAAa;QACvB,MAAM,EAAE,aAAa;KACtB;CACF,CAAA"}

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

@@ -0,0 +1,36 @@
+import type { Core, Schema } from '@astrale-os/kernel-dsl';
+import type { Layout } from '#domain/addressing/layout/types';
+import type { Domain } from './types';
+/**
+ * Compile a schema into a fully resolved CompiledDomain.
+ *
+ * The schema must have been created with `defineSchema(domain, defs)` — it
+ * carries its domain origin in `schema.domain`.
+ *
+ * All imported schemas (cross-domain defs referenced via `inherits`) must be
+ * listed in `schema.imports` so their defs can be resolved via the identity map.
+ * If any import cannot be resolved, throws CompilationError('UNRESOLVABLE_IMPORT').
+ *
+ * The returned object has two faces:
+ *   - **Flat schema members** — `K.Author`, `K.Named`, etc. (spread from refs)
+ *   - **`K.$` sigil** — engine-facing metadata: origin, refs, methods, properties,
+ *     disambiguation (`K.$.c(name)` / `K.$.i(name)`), utilities (`K.$.group`),
+ *     and lazy-memoized derivations (`K.$.inheritanceChain`, `K.$.ir`).
+ *
+ * Only one name is reserved at the top level: `$`. Schema authors can freely
+ * name classes/interfaces anything else.
+ *
+ * @throws CompilationError
+ *
+ * @example
+ * ```ts
+ * const BlogSchema = defineSchema('blog.acme.com', { Author, Post, wrote })
+ * const blog = compileDomain(BlogSchema)
+ * blog.Author.path.class         // ClassPath
+ * blog.Author.ref                // 'class.Author'
+ * blog.$.origin                  // 'blog.acme.com'
+ * blog.$.c('Author').key         // disambiguation — works even if K.Author is shadowed
+ * ```
+ */
+export declare function compileDomain<S extends Schema>(schema: S, core?: Core<S>, layout?: Layout): Domain<S>;
+//# sourceMappingURL=compile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../../domain/compile/compile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAI1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAA;AAS7D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAWrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,EAC5C,MAAM,EAAE,CAAC,EACT,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,EACd,MAAM,CAAC,EAAE,MAAM,GACd,MAAM,CAAC,CAAC,CAAC,CAwDX"}

package/dist/domain/compile/compile.js

@@ -0,0 +1,91 @@
+import { buildDefDescriptorMap } from '@astrale-os/kernel-dsl';
+import { defaultLayout } from '#domain/addressing/layout/build';
+import { buildStructuredRefs } from '#domain/addressing/refs/build';
+import { ambiguousMarker, projectFlatMaps } from '#domain/addressing/refs/project';
+import { DomainOrigin } from '#domain/origin';
+import { compileCore } from './core/compile';
+import { resolveImports } from './imports/resolve';
+import { buildDefOriginMap, scanImportedDefs } from './imports/scan';
+import { buildInternals } from './internals';
+import { resolveAllMethodsForDomain } from './method/resolve';
+import { buildPropertyMappings } from './property/build';
+import { validateDomain } from './validation/validate';
+/**
+ * Compile a schema into a fully resolved CompiledDomain.
+ *
+ * The schema must have been created with `defineSchema(domain, defs)` — it
+ * carries its domain origin in `schema.domain`.
+ *
+ * All imported schemas (cross-domain defs referenced via `inherits`) must be
+ * listed in `schema.imports` so their defs can be resolved via the identity map.
+ * If any import cannot be resolved, throws CompilationError('UNRESOLVABLE_IMPORT').
+ *
+ * The returned object has two faces:
+ *   - **Flat schema members** — `K.Author`, `K.Named`, etc. (spread from refs)
+ *   - **`K.$` sigil** — engine-facing metadata: origin, refs, methods, properties,
+ *     disambiguation (`K.$.c(name)` / `K.$.i(name)`), utilities (`K.$.group`),
+ *     and lazy-memoized derivations (`K.$.inheritanceChain`, `K.$.ir`).
+ *
+ * Only one name is reserved at the top level: `$`. Schema authors can freely
+ * name classes/interfaces anything else.
+ *
+ * @throws CompilationError
+ *
+ * @example
+ * ```ts
+ * const BlogSchema = defineSchema('blog.acme.com', { Author, Post, wrote })
+ * const blog = compileDomain(BlogSchema)
+ * blog.Author.path.class         // ClassPath
+ * blog.Author.ref                // 'class.Author'
+ * blog.$.origin                  // 'blog.acme.com'
+ * blog.$.c('Author').key         // disambiguation — works even if K.Author is shadowed
+ * ```
+ */
+export function compileDomain(schema, core, layout) {
+    // No global registry priming required: the typed-path factories
+    // used during ref construction (`ClassPath.from` etc.) lex against
+    // an internal kernel-meta grammar closure, not the global
+    // GrammarRegistry. `kernel.ts` arms the global registries via
+    // `registerKernelLanguage(K)` after this returns.
+    const origin = DomainOrigin(schema.domain);
+    const resolveLayout = layout ?? defaultLayout(origin);
+    const descriptorMap = buildDefDescriptorMap(schema);
+    const importedDefDomains = scanImportedDefs(schema);
+    const imports = resolveImports(schema, importedDefDomains);
+    const defOrigins = buildDefOriginMap(schema, importedDefDomains);
+    // Property index built up-front so `compileCore` can qualify user-input
+    // bare keys to canonical storage form once at compile time. Per spec
+    // (kernel.md §16): writes accept bare/owner/domain/qualified, reads
+    // return qualified. `CompiledCoreEntry.data` is a read-side contract.
+    const properties = Object.freeze(buildPropertyMappings(schema, imports));
+    const compiledCore = core
+        ? compileCore(core, origin, descriptorMap, properties, defOrigins)
+        : undefined;
+    const refs = buildStructuredRefs(schema, origin, resolveLayout, compiledCore);
+    const { keys, paths } = projectFlatMaps(refs);
+    const methods = Object.freeze(resolveAllMethodsForDomain(schema, origin));
+    const warnings = Object.freeze(validateDomain(origin, properties, schema, methods));
+    const $ = buildInternals({
+        origin,
+        schema,
+        layout: resolveLayout,
+        refs,
+        keys,
+        paths,
+        imports,
+        core: compiledCore,
+        properties,
+        methods,
+        warnings,
+    });
+    // Flat surface. A homonym (a name that is both a class and an interface, e.g.
+    // `Function`) is NOT resolved to either entry: it carries an `ambiguousMarker`
+    // so `K.Function` fails — callers must use `K.$.c(name)` / `K.$.i(name)`.
+    const flat = { ...refs.classes, ...refs.interfaces };
+    for (const name of Object.keys(refs.classes)) {
+        if (name in refs.interfaces)
+            flat[name] = ambiguousMarker(name);
+    }
+    return Object.freeze({ $, ...flat });
+}
+//# sourceMappingURL=compile.js.map

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

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

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

@@ -0,0 +1,66 @@
+/**
+ * CompiledCore — first-class identity for core (genesis) instance data.
+ *
+ * Mirrors the schema identity pattern: refs, keys, paths, externalIds.
+ * Produced by compileCore(), consumed by serialize() and installDomain().
+ */
+import type { AnyDef, Core, DefDescriptor } from '@astrale-os/kernel-dsl';
+import type { DomainOrigin } from '#domain/origin';
+import type { AbsolutePath } from '#graph/tree';
+import type { ExternalId } from '#ids';
+import type { DomainPropertyIndex } from '../property/types';
+import type { CoreRefsMap, CoreKeysMap, CorePathsMap, CoreExternalIdsMap } from './types';
+export interface CompiledCoreEntry {
+    readonly ref: string;
+    readonly className: string;
+    /** Declaring domain of the class — differs from the current origin when
+     * `defineCore` references a class from an imported schema. */
+    readonly classDomain: DomainOrigin;
+    readonly path: AbsolutePath;
+    readonly externalId: ExternalId;
+    readonly parentRef: string | undefined;
+    readonly data: Readonly<Record<string, unknown>>;
+}
+export interface CompiledCoreEdge {
+    readonly className: string;
+    readonly classDomain: DomainOrigin;
+    readonly fromPath: AbsolutePath;
+    readonly toPath: AbsolutePath;
+    readonly data: Readonly<Record<string, unknown>>;
+}
+/**
+ * Compiled core instance data — first-class identity for genesis nodes + edges.
+ *
+ * Provides refs, keys, paths, externalIds — mirroring schema identity. This is
+ * the single source of truth consumed by serialize(); the raw builder `Core`
+ * is not preserved because nothing downstream needs it.
+ */
+export interface CompiledCore {
+    /** Core ref → ref identity map (flat, includes nested via dot notation). */
+    readonly refs: CoreRefsMap;
+    /** Core ref → global key (domain:core.ref). */
+    readonly keys: CoreKeysMap;
+    /** Core ref → AbsolutePath (graph tree position). */
+    readonly paths: CorePathsMap;
+    /** Core ref → deterministic ExternalId. Used to map PushResult → NodeIds at install. */
+    readonly externalIds: CoreExternalIdsMap;
+    /** Core ref → entry metadata (class name, properties, parent ref). */
+    readonly entries: Readonly<Record<string, CompiledCoreEntry>>;
+    /** User-defined edges between core nodes (structural kernel edges excluded). */
+    readonly edges: readonly CompiledCoreEdge[];
+}
+/**
+ * Compile core instance data into a CompiledCore.
+ *
+ * Walks `core.__nodes` / `core.__edges` to build identity maps and entry
+ * metadata. The result is immutable and deterministic.
+ *
+ * Per spec (kernel.md §16): property *writes* accept bare / owner / domain /
+ * qualified shapes; property *reads* always return fully-qualified keys.
+ * `CompiledCoreEntry.data` is a read-side contract — every consumer
+ * (`serializeCore`, deserialize round-trip, install pipeline) sees keys in
+ * `<domain>:class.<C>.property.<p>` / `<domain>:interface.<I>.property.<p>`
+ * form. The bare → qualified rewrite happens here, exactly once.
+ */
+export declare function compileCore(core: Core, origin: DomainOrigin, descriptorMap: Map<AnyDef, DefDescriptor>, properties: DomainPropertyIndex, defOrigins: Map<AnyDef, DomainOrigin>): CompiledCore;
+//# sourceMappingURL=compile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../../../domain/compile/core/compile.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,MAAM,EACN,IAAI,EAGJ,aAAa,EAEd,MAAM,wBAAwB,CAAA;AAK/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAA;AAUtC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAIzF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B;kEAC8D;IAC9D,QAAQ,CAAC,WAAW,EAAE,YAAY,CAAA;IAClC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CACjD;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,WAAW,EAAE,YAAY,CAAA;IAClC,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAA;IAC/B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;IAC7B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CACjD;AAED;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAE1B,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAE1B,qDAAqD;IACrD,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAA;IAE5B,wFAAwF;IACxF,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAA;IAExC,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAA;IAE7D,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,SAAS,gBAAgB,EAAE,CAAA;CAC5C;AAID;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,YAAY,EACpB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,EACzC,UAAU,EAAE,mBAAmB,EAC/B,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,GACpC,YAAY,CAuId"}