@astrale-os/kernel-core 0.4.1

package/dist/domain/addressing/refs/errors.d.ts

@@ -0,0 +1,12 @@
+/** Error thrown when a ref string cannot be parsed. */
+export declare class RefParseError extends Error {
+    readonly raw: string;
+    readonly reason: string;
+    constructor(raw: string, reason: string);
+}
+/** Error thrown when two refs would collide in a single domain. */
+export declare class RefCollisionError extends Error {
+    readonly ref: string;
+    constructor(ref: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/domain/addressing/refs/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../domain/addressing/refs/errors.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,qBAAa,aAAc,SAAQ,KAAK;IACtC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IAEvB,YAAY,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAKtC;CACF;AAED,mEAAmE;AACnE,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IAEpB,YAAY,GAAG,EAAE,MAAM,EAItB;CACF"}

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

@@ -0,0 +1,21 @@
+/** Error thrown when a ref string cannot be parsed. */
+export class RefParseError extends Error {
+    raw;
+    reason;
+    constructor(raw, reason) {
+        super(`Invalid ref "${raw}": ${reason}`);
+        this.name = 'RefParseError';
+        this.raw = raw;
+        this.reason = reason;
+    }
+}
+/** Error thrown when two refs would collide in a single domain. */
+export class RefCollisionError extends Error {
+    ref;
+    constructor(ref) {
+        super(`Domain ref collision: '${ref}' is already defined`);
+        this.name = 'RefCollisionError';
+        this.ref = ref;
+    }
+}
+//# sourceMappingURL=errors.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../../domain/addressing/refs/errors.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,MAAM,OAAO,aAAc,SAAQ,KAAK;IAC7B,GAAG,CAAQ;IACX,MAAM,CAAQ;IAEvB,YAAY,GAAW,EAAE,MAAc;QACrC,KAAK,CAAC,gBAAgB,GAAG,MAAM,MAAM,EAAE,CAAC,CAAA;QACxC,IAAI,CAAC,IAAI,GAAG,eAAe,CAAA;QAC3B,IAAI,CAAC,GAAG,GAAG,GAAG,CAAA;QACd,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;IACtB,CAAC;CACF;AAED,mEAAmE;AACnE,MAAM,OAAO,iBAAkB,SAAQ,KAAK;IACjC,GAAG,CAAQ;IAEpB,YAAY,GAAW;QACrB,KAAK,CAAC,0BAA0B,GAAG,sBAAsB,CAAC,CAAA;QAC1D,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAA;QAC/B,IAAI,CAAC,GAAG,GAAG,GAAG,CAAA;IAChB,CAAC;CACF"}

package/dist/domain/addressing/refs/index.d.ts

@@ -0,0 +1,7 @@
+export type { DomainRefs, GroupedRef, MemberRefEntry, MemberRefPath, MethodRefEntry, MethodRefPath, RefEntry, RefPath, } from './types';
+export { Ref, SEGMENT_SEP } from './ref';
+export { RefParseError, RefCollisionError } from './errors';
+export { buildStructuredRefs } from './build';
+export { iterateRefs } from './iterate';
+export { projectFlatMaps } from './project';
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/addressing/refs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../domain/addressing/refs/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,UAAU,EACV,UAAU,EACV,cAAc,EACd,aAAa,EACb,cAAc,EACd,aAAa,EACb,QAAQ,EACR,OAAO,GACR,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,OAAO,CAAA;AACxC,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AACvC,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA"}

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

@@ -0,0 +1,6 @@
+export { Ref, SEGMENT_SEP } from './ref';
+export { RefParseError, RefCollisionError } from './errors';
+export { buildStructuredRefs } from './build';
+export { iterateRefs } from './iterate';
+export { projectFlatMaps } from './project';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../domain/addressing/refs/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,OAAO,CAAA;AACxC,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AACvC,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA"}

package/dist/domain/addressing/refs/iterate.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Generator over structured domain refs.
+ *
+ * Yields rich RefEntry entries from a DomainRefs object.
+ * Each yielded entry has .ref, .key, .path — the full identity.
+ *
+ * Used by compileDomain to project flat maps (keys, path.domain, path.absolute)
+ * from the already-built rich refs.
+ */
+import type { DomainRefs, RefEntry } from './types';
+/**
+ * Yield every ref from a DomainRefs as a rich entry.
+ *
+ * Order: interfaces (member then methods), classes (member then methods), core.
+ */
+export declare function iterateRefs(refs: DomainRefs): Generator<RefEntry>;
+//# sourceMappingURL=iterate.d.ts.map

package/dist/domain/addressing/refs/iterate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate.d.ts","sourceRoot":"","sources":["../../../../domain/addressing/refs/iterate.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAkB,QAAQ,EAAE,MAAM,SAAS,CAAA;AAEnE;;;;GAIG;AACH,wBAAiB,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,CAAC,QAAQ,CAAC,CAQlE"}

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

@@ -0,0 +1,42 @@
+/**
+ * Generator over structured domain refs.
+ *
+ * Yields rich RefEntry entries from a DomainRefs object.
+ * Each yielded entry has .ref, .key, .path — the full identity.
+ *
+ * Used by compileDomain to project flat maps (keys, path.domain, path.absolute)
+ * from the already-built rich refs.
+ */
+/**
+ * Yield every ref from a DomainRefs as a rich entry.
+ *
+ * Order: interfaces (member then methods), classes (member then methods), core.
+ */
+export function* iterateRefs(refs) {
+    yield* iterateGroup(refs.interfaces);
+    yield* iterateGroup(refs.classes);
+    yield* iterateCoreGroup(refs.core);
+}
+function* iterateGroup(defs) {
+    for (const entry of Object.values(defs)) {
+        // Yield the member ref itself
+        yield entry;
+        // Yield method refs — skip structural fields (ref/key/path/$) and any
+        // sub-entry without a .path (property refs, the accessors bundle).
+        for (const [key, value] of Object.entries(entry)) {
+            if (key === 'ref' || key === 'key' || key === 'path' || key === '$')
+                continue;
+            if (typeof value !== 'object' || value === null)
+                continue;
+            if (!('path' in value))
+                continue;
+            yield value;
+        }
+    }
+}
+function* iterateCoreGroup(core) {
+    for (const entry of Object.values(core)) {
+        yield entry;
+    }
+}
+//# sourceMappingURL=iterate.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"iterate.js","sourceRoot":"","sources":["../../../../domain/addressing/refs/iterate.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH;;;;GAIG;AACH,MAAM,SAAS,CAAC,CAAC,WAAW,CAAC,IAAgB;IAC3C,KAAK,CAAC,CAAC,YAAY,CACjB,IAAI,CAAC,UAAgF,CACtF,CAAA;IACD,KAAK,CAAC,CAAC,YAAY,CACjB,IAAI,CAAC,OAA6E,CACnF,CAAA;IACD,KAAK,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AACpC,CAAC;AAED,QAAQ,CAAC,CAAC,YAAY,CACpB,IAAwE;IAExE,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;QACxC,8BAA8B;QAC9B,MAAM,KAAiB,CAAA;QAEvB,sEAAsE;QACtE,mEAAmE;QACnE,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACjD,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK,MAAM,IAAI,GAAG,KAAK,GAAG;gBAAE,SAAQ;YAC7E,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;gBAAE,SAAQ;YACzD,IAAI,CAAC,CAAC,MAAM,IAAI,KAAK,CAAC;gBAAE,SAAQ;YAChC,MAAM,KAAiB,CAAA;QACzB,CAAC;IACH,CAAC;AACH,CAAC;AAED,QAAQ,CAAC,CAAC,gBAAgB,CACxB,IAA0D;IAE1D,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;QACxC,MAAM,KAAK,CAAA;IACb,CAAC;AACH,CAAC"}

package/dist/domain/addressing/refs/project.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Project flat maps (keys, paths.absolute, paths.class) from rich refs.
+ *
+ * Used by compileDomain to derive iteration-friendly flat maps from the
+ * structured DomainRefs. Lives here because it's a pure projection over
+ * iterateRefs output.
+ */
+import type { DomainKeysMap } from '#domain/addressing/keys/types';
+import type { LayoutMap } from '#domain/addressing/layout/types';
+import type { ClassPathMap } from '#domain/compile/types';
+import type { AmbiguousMember, DomainRefs } from './types';
+/**
+ * Runtime marker placed at a homonym name on the flat surface (`K.Function`),
+ * so runtime matches the `AmbiguousMember` type: the key exists but carries a
+ * hint instead of a usable entry. Keep the message in sync with the literal in
+ * `AmbiguousMember` (`addressing/refs/types.ts`).
+ */
+export declare function ambiguousMarker<K extends string>(name: K): AmbiguousMember<K>;
+export declare function projectFlatMaps(refs: DomainRefs): {
+    keys: DomainKeysMap;
+    paths: {
+        readonly absolute: LayoutMap;
+        readonly class: ClassPathMap;
+    };
+};
+//# sourceMappingURL=project.d.ts.map

package/dist/domain/addressing/refs/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../../domain/addressing/refs/project.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAA;AAClE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAA;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAGzD,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAkB,MAAM,SAAS,CAAA;AAI1E;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAI7E;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG;IACjD,IAAI,EAAE,aAAa,CAAA;IACnB,KAAK,EAAE;QAAE,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAA;KAAE,CAAA;CACtE,CAoBA"}

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

@@ -0,0 +1,39 @@
+/**
+ * Project flat maps (keys, paths.absolute, paths.class) from rich refs.
+ *
+ * Used by compileDomain to derive iteration-friendly flat maps from the
+ * structured DomainRefs. Lives here because it's a pure projection over
+ * iterateRefs output.
+ */
+import { iterateRefs } from './iterate';
+/**
+ * Runtime marker placed at a homonym name on the flat surface (`K.Function`),
+ * so runtime matches the `AmbiguousMember` type: the key exists but carries a
+ * hint instead of a usable entry. Keep the message in sync with the literal in
+ * `AmbiguousMember` (`addressing/refs/types.ts`).
+ */
+export function ambiguousMarker(name) {
+    return Object.freeze({
+        __ambiguous: `'${name}' is both a class and an interface — use K.$.c('${name}') for the class or K.$.i('${name}') for the interface`,
+    });
+}
+export function projectFlatMaps(refs) {
+    const keys = {};
+    const absolute = {};
+    const classMap = {};
+    for (const entry of iterateRefs(refs)) {
+        keys[entry.ref] = entry.key;
+        absolute[entry.ref] = entry.path.absolute;
+        if ('class' in entry.path) {
+            classMap[entry.ref] = entry.path.class;
+        }
+    }
+    return {
+        keys: keys,
+        paths: Object.freeze({
+            absolute: Object.freeze(absolute),
+            class: Object.freeze(classMap),
+        }),
+    };
+}
+//# sourceMappingURL=project.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"project.js","sourceRoot":"","sources":["../../../../domain/addressing/refs/project.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAUH,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAEvC;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAmB,IAAO;IACvD,OAAO,MAAM,CAAC,MAAM,CAAC;QACnB,WAAW,EAAE,IAAI,IAAI,mDAAmD,IAAI,8BAA8B,IAAI,sBAAsB;KACrI,CAAuB,CAAA;AAC1B,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,IAAgB;IAI9C,MAAM,IAAI,GAA2B,EAAE,CAAA;IACvC,MAAM,QAAQ,GAAiC,EAAE,CAAA;IACjD,MAAM,QAAQ,GAA8B,EAAE,CAAA;IAE9C,KAAK,MAAM,KAAK,IAAI,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;QACtC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,CAAA;QAC3B,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAA;QACzC,IAAI,OAAO,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;YAC1B,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,GAAI,KAAqD,CAAC,IAAI,CAAC,KAAK,CAAA;QACzF,CAAC;IACH,CAAC;IAED,OAAO;QACL,IAAI,EAAE,IAAqB;QAC3B,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC;YACnB,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAc;YAC9C,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAiB;SAC/C,CAAC;KACH,CAAA;AACH,CAAC"}

package/dist/domain/addressing/refs/ref.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Ref — the domain-scoped address value type.
+ *
+ * A Ref identifies an addressable element within a domain using a namespace
+ * prefix followed by N dot-separated segments:
+ *
+ *   'class.Author'                       → member   (segments: ['Author'])
+ *   'class.Author.method.deactivate'     → method   (segments: ['Author', 'method', 'deactivate'])
+ *   'class.Author.property.bio'          → property (segments: ['Author', 'property', 'bio'])
+ *   'interface.Named'                    → member   (segments: ['Named'])
+ *   'interface.Named.method.format'      → method   (segments: ['Named', 'method', 'format'])
+ *   'interface.Named.property.name'      → property (segments: ['Named', 'property', 'name'])
+ *   'core.global'                        → member   (segments: ['global'])
+ *
+ * The namespace determines the node kind. The segments encode the hierarchical
+ * address within that namespace. The segment count and semantics are
+ * namespace-dependent and extensible — Ref itself is segment-count-agnostic.
+ *
+ * This is the SINGLE owner of the '.' separator in ref strings.
+ * No other module should indexOf('.') or template-literal dot-join to build refs.
+ */
+import type { Namespace } from '#domain/addressing/namespace';
+/**
+ * Segment separator — `.` is the dot that joins a ref's namespace and segments.
+ *
+ * Ref is the SINGLE owner of this character. Other modules that need a
+ * dot-separated grammar (e.g., the property shortcut parser) should import
+ * this constant rather than hardcode `'.'`.
+ */
+export declare const SEGMENT_SEP: '.';
+export declare class Ref {
+    readonly namespace: Namespace;
+    readonly segments: readonly string[];
+    private constructor();
+    /** Create a member ref: `class.Author`, `interface.Named`, `core.global` */
+    static member(namespace: Namespace, name: string): Ref;
+    /** Create a method ref: `class.Author.method.deactivate` */
+    static method(namespace: Namespace, owner: string, methodName: string): Ref;
+    /** Create a property ref: `class.Author.property.bio` */
+    static property(namespace: Namespace, owner: string, propName: string): Ref;
+    /**
+     * Parse a ref string into a Ref.
+     *
+     * This is THE single parser for ref strings. All other modules delegate here.
+     * Splits on all dots: first segment is namespace, rest are segments.
+     *
+     * @throws RefParseError if the string is malformed or has an invalid namespace.
+     */
+    static parse(raw: string): Ref;
+    /** Try to parse — returns null instead of throwing. */
+    static tryParse(raw: string): Ref | null;
+    /** First segment — the member name (class/interface/core name, or owner for method/property). */
+    get member(): string;
+    /** Third segment — the child name (method name, property name, etc.). */
+    get child(): string | undefined;
+    /** Second segment — the discriminator ('method', 'property', etc.). */
+    get discriminator(): string | undefined;
+    /** True if this is a method ref (discriminator is 'method'). */
+    get isMethod(): boolean;
+    /** True if this is a property ref (discriminator is 'property'). */
+    get isProperty(): boolean;
+    /** True if this is a member-level ref (single segment, no discriminator). */
+    get isMember(): boolean;
+    /**
+     * The member-level ref (strips child segments).
+     * For 'class.Author.method.deactivate' → Ref('class', 'Author').
+     * For a member ref, returns itself.
+     */
+    get memberRef(): Ref;
+    /**
+     * The namespace-qualified member name: 'class.Author'.
+     * Used as the of_domain edge slug and folder name in layout.
+     */
+    get qualified(): string;
+    /** The full ref string: 'class.Author.method.deactivate' or 'class.Author'. */
+    toString(): string;
+    /** Equality check. */
+    equals(other: Ref): boolean;
+}
+//# sourceMappingURL=ref.d.ts.map

package/dist/domain/addressing/refs/ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref.d.ts","sourceRoot":"","sources":["../../../../domain/addressing/refs/ref.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAM7D;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,EAAG,GAAY,CAAA;AAEvC,qBAAa,GAAG;IACd,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;IAC7B,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;IAEpC,OAAO,eAGN;IAID,4EAA4E;IAC5E,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,GAAG,CAErD;IAED,4DAA4D;IAC5D,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,GAAG,CAE1E;IAED,yDAAyD;IACzD,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,GAAG,CAE1E;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAgB7B;IAED,uDAAuD;IACvD,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,GAAG,IAAI,CAMvC;IAID,iGAAiG;IACjG,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,yEAAyE;IACzE,IAAI,KAAK,IAAI,MAAM,GAAG,SAAS,CAE9B;IAED,uEAAuE;IACvE,IAAI,aAAa,IAAI,MAAM,GAAG,SAAS,CAEtC;IAID,gEAAgE;IAChE,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,oEAAoE;IACpE,IAAI,UAAU,IAAI,OAAO,CAExB;IAED,6EAA6E;IAC7E,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED;;;;OAIG;IACH,IAAI,SAAS,IAAI,GAAG,CAGnB;IAED;;;OAGG;IACH,IAAI,SAAS,IAAI,MAAM,CAEtB;IAID,+EAA+E;IAC/E,QAAQ,IAAI,MAAM,CAEjB;IAED,sBAAsB;IACtB,MAAM,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAO1B;CACF"}

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

@@ -0,0 +1,146 @@
+/**
+ * Ref — the domain-scoped address value type.
+ *
+ * A Ref identifies an addressable element within a domain using a namespace
+ * prefix followed by N dot-separated segments:
+ *
+ *   'class.Author'                       → member   (segments: ['Author'])
+ *   'class.Author.method.deactivate'     → method   (segments: ['Author', 'method', 'deactivate'])
+ *   'class.Author.property.bio'          → property (segments: ['Author', 'property', 'bio'])
+ *   'interface.Named'                    → member   (segments: ['Named'])
+ *   'interface.Named.method.format'      → method   (segments: ['Named', 'method', 'format'])
+ *   'interface.Named.property.name'      → property (segments: ['Named', 'property', 'name'])
+ *   'core.global'                        → member   (segments: ['global'])
+ *
+ * The namespace determines the node kind. The segments encode the hierarchical
+ * address within that namespace. The segment count and semantics are
+ * namespace-dependent and extensible — Ref itself is segment-count-agnostic.
+ *
+ * This is the SINGLE owner of the '.' separator in ref strings.
+ * No other module should indexOf('.') or template-literal dot-join to build refs.
+ */
+import { isNamespace } from '#domain/addressing/namespace';
+import { RefParseError } from './errors';
+/**
+ * Segment separator — `.` is the dot that joins a ref's namespace and segments.
+ *
+ * Ref is the SINGLE owner of this character. Other modules that need a
+ * dot-separated grammar (e.g., the property shortcut parser) should import
+ * this constant rather than hardcode `'.'`.
+ */
+export const SEGMENT_SEP = '.';
+export class Ref {
+    namespace;
+    segments;
+    constructor(namespace, segments) {
+        this.namespace = namespace;
+        this.segments = segments;
+    }
+    // ── Factories ──────────────────────────────────────────────────────
+    /** Create a member ref: `class.Author`, `interface.Named`, `core.global` */
+    static member(namespace, name) {
+        return new Ref(namespace, [name]);
+    }
+    /** Create a method ref: `class.Author.method.deactivate` */
+    static method(namespace, owner, methodName) {
+        return new Ref(namespace, [owner, 'method', methodName]);
+    }
+    /** Create a property ref: `class.Author.property.bio` */
+    static property(namespace, owner, propName) {
+        return new Ref(namespace, [owner, 'property', propName]);
+    }
+    /**
+     * Parse a ref string into a Ref.
+     *
+     * This is THE single parser for ref strings. All other modules delegate here.
+     * Splits on all dots: first segment is namespace, rest are segments.
+     *
+     * @throws RefParseError if the string is malformed or has an invalid namespace.
+     */
+    static parse(raw) {
+        const firstDot = raw.indexOf(SEGMENT_SEP);
+        if (firstDot === -1)
+            throw new RefParseError(raw, 'missing namespace separator');
+        const ns = raw.slice(0, firstDot);
+        if (!isNamespace(ns))
+            throw new RefParseError(raw, `invalid namespace "${ns}"`);
+        const rest = raw.slice(firstDot + 1);
+        if (rest.length === 0)
+            throw new RefParseError(raw, 'missing member name');
+        const segments = rest.split(SEGMENT_SEP);
+        if (segments.some((s) => s.length === 0)) {
+            throw new RefParseError(raw, 'empty segment');
+        }
+        return new Ref(ns, segments);
+    }
+    /** Try to parse — returns null instead of throwing. */
+    static tryParse(raw) {
+        try {
+            return Ref.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    // ── Positional accessors ──────────────────────────────────────────
+    /** First segment — the member name (class/interface/core name, or owner for method/property). */
+    get member() {
+        return this.segments[0];
+    }
+    /** Third segment — the child name (method name, property name, etc.). */
+    get child() {
+        return this.segments[2];
+    }
+    /** Second segment — the discriminator ('method', 'property', etc.). */
+    get discriminator() {
+        return this.segments.length > 1 ? this.segments[1] : undefined;
+    }
+    // ── Computed ───────────────────────────────────────────────────────
+    /** True if this is a method ref (discriminator is 'method'). */
+    get isMethod() {
+        return this.segments[1] === 'method';
+    }
+    /** True if this is a property ref (discriminator is 'property'). */
+    get isProperty() {
+        return this.segments[1] === 'property';
+    }
+    /** True if this is a member-level ref (single segment, no discriminator). */
+    get isMember() {
+        return this.segments.length === 1;
+    }
+    /**
+     * The member-level ref (strips child segments).
+     * For 'class.Author.method.deactivate' → Ref('class', 'Author').
+     * For a member ref, returns itself.
+     */
+    get memberRef() {
+        if (this.segments.length === 1)
+            return this;
+        return new Ref(this.namespace, [this.segments[0]]);
+    }
+    /**
+     * The namespace-qualified member name: 'class.Author'.
+     * Used as the of_domain edge slug and folder name in layout.
+     */
+    get qualified() {
+        return `${this.namespace}${SEGMENT_SEP}${this.segments[0]}`;
+    }
+    // ── String representation ─────────────────────────────────────────
+    /** The full ref string: 'class.Author.method.deactivate' or 'class.Author'. */
+    toString() {
+        return `${this.namespace}${SEGMENT_SEP}${this.segments.join(SEGMENT_SEP)}`;
+    }
+    /** Equality check. */
+    equals(other) {
+        if (this.namespace !== other.namespace)
+            return false;
+        if (this.segments.length !== other.segments.length)
+            return false;
+        for (let i = 0; i < this.segments.length; i++) {
+            if (this.segments[i] !== other.segments[i])
+                return false;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=ref.js.map

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

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

package/dist/domain/addressing/refs/types.d.ts

@@ -0,0 +1,167 @@
+/**
+ * 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
+ */
+import type { ExtractMethods, ExtractProperties, Schema } from '@astrale-os/kernel-dsl';
+import type { ClassPath } from '#domain';
+import type { DomainKey } from '#domain/addressing/keys/types';
+import type { Namespace } from '#domain/addressing/namespace';
+import type { DomainPath } from '#domain/addressing/paths/domain';
+import type { InterfacePath } from '#domain/addressing/paths/interface';
+import type { MethodPath } from '#domain/addressing/paths/method';
+import type { Path } from '#graph/nav/path';
+import type { AbsolutePath } from '#graph/tree';
+/** Path bundle for a class/interface/edge member. Has all three addressing modes. */
+export interface MemberRefPath {
+    /**
+     * Semantic domain path — stable, independent of tree layout. Typed
+     * narrowly to the member's kind: `ClassPath` for class members,
+     * `InterfacePath` for interface members, `DomainPath` for the generic
+     * fallback (e.g., kernel core refs).
+     */
+    readonly domain: ClassPath | InterfacePath | DomainPath;
+    /** Tree position — layout-dependent, matches DB-returned paths. */
+    readonly absolute: AbsolutePath;
+    /** Type identity — domain-qualified class reference. */
+    readonly class: ClassPath;
+}
+/** Path bundle for a method. */
+export interface MethodRefPath {
+    /** Semantic method path — stable, independent of tree layout. */
+    readonly method: MethodPath;
+    /** Tree position — layout-dependent, matches DB-returned paths. */
+    readonly absolute: AbsolutePath;
+}
+/** Base path bundle for generic iteration (flatten, from-graph). */
+export interface RefPath {
+    /** Semantic traversal path — stable, independent of tree layout. */
+    readonly domain: Path;
+    /** Tree position — layout-dependent, matches DB-returned paths. */
+    readonly absolute: AbsolutePath;
+}
+/** A namespace-prefixed ref string: `'class.Author'`, `'interface.Named.method.format'`, `'core.alice'`. */
+export type GroupedRef = `${Namespace}.${string}`;
+/**
+ * Disambiguation accessors for a member entry — bundled under `$` so they
+ * don't pollute the flat method/property surface.
+ *
+ * Methods and properties are spread flat on the entry (`K.Foo.describe.key`,
+ * `K.Foo.bio.key`). When a name collides with the entry's structural fields
+ * (`ref`, `key`, `path`, `$`) or with another same-named sibling, the
+ * `$` accessors always return the right entry.
+ */
+export interface MemberRefAccessors {
+    /** Look up a method entry by name — bypasses flat-spread shadowing. */
+    m(name: string): MethodRefEntry | undefined;
+    /** Look up a property entry by name — bypasses flat-spread shadowing. */
+    p(name: string): PropertyRefEntry | undefined;
+}
+/** A rich member ref entry — class/interface/edge definitions. */
+export interface MemberRefEntry<Ref extends string = string> {
+    readonly ref: Ref;
+    readonly key: DomainKey<Ref>;
+    readonly path: MemberRefPath;
+    /** Disambiguation accessors — `$m(name)` and `$p(name)` live here. */
+    readonly $: MemberRefAccessors;
+}
+/** A rich method ref entry. */
+export interface MethodRefEntry<Ref extends string = string> {
+    readonly ref: Ref;
+    readonly key: DomainKey<Ref>;
+    readonly path: MethodRefPath;
+}
+/** A rich property ref entry. Properties have no tree position, so no path. */
+export interface PropertyRefEntry<Ref extends string = string> {
+    readonly ref: Ref;
+    readonly key: DomainKey<Ref>;
+}
+/** Base ref entry for generic code (iteration, deserialization). */
+export interface RefEntry<Ref extends string = string> {
+    readonly ref: Ref;
+    readonly key: DomainKey<Ref>;
+    readonly path: RefPath;
+}
+/** Maps own method names to their rich MethodRefEntry entries. */
+type MethodRefs<D, Prefix extends string> = {
+    readonly [M in keyof ExtractMethods<D> & string]: MethodRefEntry<`${Prefix}.method.${M}`>;
+};
+/** Maps own property names to their rich PropertyRefEntry entries. */
+type PropertyRefs<D, Prefix extends string> = {
+    readonly [P in keyof ExtractProperties<D> & string]: PropertyRefEntry<`${Prefix}.property.${P}`>;
+};
+/**
+ * Structured refs for a compiled domain.
+ *
+ * Groups all definition refs by kind (interface, class, core) with typed
+ * accessors. Member entries carry MemberRefEntry (with ClassPath), method
+ * entries carry MethodRefEntry.
+ *
+ * @example
+ * ```ts
+ * const blog = compileDomain(BlogSchema)
+ * blog.refs.classes.Author.path.class       // ClassPath
+ * blog.refs.classes.Author.path.domain      // DomainPath
+ * blog.refs.classes.Author.path.absolute    // AbsolutePath
+ * blog.refs.classes.Author.describe.path.method // MethodPath
+ * ```
+ */
+export interface DomainRefs<S extends Schema = Schema> {
+    readonly interfaces: {
+        readonly [K in keyof S['interfaces'] & string]: MemberRefEntry<`interface.${K}`> & MethodRefs<S['interfaces'][K], `interface.${K}`> & PropertyRefs<S['interfaces'][K], `interface.${K}`>;
+    };
+    readonly classes: {
+        readonly [K in keyof S['classes'] & string]: MemberRefEntry<`class.${K}`> & MethodRefs<S['classes'][K], `class.${K}`> & PropertyRefs<S['classes'][K], `class.${K}`>;
+    };
+    readonly core: Readonly<Record<string, RefEntry<`core.${string}`>>>;
+}
+/** Names that are BOTH a class and an interface in a schema (homonyms, e.g. `Function`). */
+type Homonyms<S extends Schema> = keyof S['interfaces'] & keyof S['classes'] & string;
+/**
+ * Placeholder a homonym name maps to on the flat surface. It carries a readable
+ * hint in its type instead of a usable ref entry, so flat access (`K.Function`)
+ * fails to type-check with a message pointing at the disambiguation accessors.
+ *
+ * Keep this literal in sync with `ambiguousMarker` in `compile/compile.ts` — a
+ * type and a runtime value can't share one source.
+ */
+export interface AmbiguousMember<K extends string> {
+    readonly __ambiguous: `'${K}' is both a class and an interface — use K.$.c('${K}') for the class or K.$.i('${K}') for the interface`;
+}
+/**
+ * Flat member accessor for a compiled domain (`K.Author`, …).
+ *
+ * Mirrors the runtime spread `{ ...refs.classes, ...refs.interfaces }`, except a
+ * name that is BOTH a class and an interface (a homonym, e.g. `Function`) does
+ * NOT resolve to either entry: it maps to `AmbiguousMember`, so `K.Function`
+ * fails to type-check and forces the explicit `K.$.c('Function')` (class) or
+ * `K.$.i('Function')` (interface). Plainly intersecting the two groups
+ * (`DomainRefs<S>['classes'] & DomainRefs<S>['interfaces']`) would instead
+ * collide their conflicting literal `ref` fields (`'class.Function'` vs
+ * `'interface.Function'`) and collapse the homonym entry to `never`.
+ */
+export type FlatRefs<S extends Schema = Schema> = {
+    readonly [K in (keyof S['interfaces'] | keyof S['classes']) & string]: K extends Homonyms<S> ? AmbiguousMember<K> : K extends keyof S['interfaces'] ? DomainRefs<S>['interfaces'][K] : K extends keyof S['classes'] ? DomainRefs<S>['classes'][K] : never;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/domain/addressing/refs/types.d.ts.map

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