@astrale-os/kernel-core 0.4.1

package/dist/domain/addressing/grammar/set.js

@@ -0,0 +1,31 @@
+/**
+ * The grammar set every kernel-meta typed-path factory lexes against.
+ *
+ * Closed over at module load and passed to {@link parseStepsWith} from
+ * `*Path.from(fields)` factory call sites — `ClassPath`, `DomainPath`,
+ * `InterfacePath`, `MethodPath`. Decoupling these factories from the
+ * global {@link GrammarRegistry} eliminates the boot-order coupling
+ * that previously required auto-register-on-import + a defensive
+ * re-arm inside `compileDomain`.
+ *
+ * Includes both universal grammars (absolute, relative) and
+ * kernel-meta grammars (domain, instance-method) — the union the
+ * factories may need to lex any raw they construct. Extra grammars in
+ * the set are harmless: tokens that don't appear in the input are
+ * never matched.
+ *
+ * Note: not exported from `paths/index.ts`. Internal to the path
+ * factories' bootstrap-bypass implementation; consumers should use
+ * the typed `*Path.from(...)` API, not this list.
+ */
+import { absoluteGrammar } from '#graph/tree/path/absolute/grammar';
+import { relativeGrammar } from '#graph/tree/path/relative/grammar';
+import { domainGrammar } from './domain';
+import { instanceMethodGrammar } from './instance-method';
+export const KERNEL_META_PATH_GRAMMARS = [
+    absoluteGrammar,
+    relativeGrammar,
+    domainGrammar,
+    instanceMethodGrammar,
+];
+//# sourceMappingURL=set.js.map

package/dist/domain/addressing/grammar/set.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set.js","sourceRoot":"","sources":["../../../../domain/addressing/grammar/set.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAA;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAA;AAEnE,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAA;AAEzD,MAAM,CAAC,MAAM,yBAAyB,GAAgC;IACpE,eAAe;IACf,eAAe;IACf,aAAa;IACb,qBAAqB;CACtB,CAAA"}

package/dist/domain/addressing/grammar/tokens.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Domain separator — `:` is the universal domain-realm delimiter.
+ *
+ * Positional meaning:
+ * - `:domain`              → installed_in
+ * - `:domain:member`       → installed_in + of_domain
+ * - `:domain:member:method` → installed_in + of_domain + method_of
+ */
+export declare const DOMAIN_SEP: ':';
+/**
+ * Instance dispatch separator — `::` means instance_of → method_of.
+ *
+ * Used from any node to call a method defined on its type:
+ * - `@instanceId::send`            → instance_of + method_of
+ * - `:messaging:Message::create`   → ... + instance_of + method_of
+ */
+export declare const INSTANCE_SEP: '::';
+/**
+ * Regex for valid domain names. A domain name is a DNS-like dotted
+ * sequence of slug segments. Looser than tree slugs because dots are
+ * allowed within (e.g., `kernel.astrale.ai`).
+ */
+export declare const DOMAIN_NAME_RE: RegExp;
+/**
+ * Regex for member slug bodies — class names, interface names, method
+ * names, or qualified forms like `class.Foo` and `interface.Bar`. The
+ * discriminator is the prefix when present, not the regex itself.
+ */
+export declare const MEMBER_SLUG_RE: RegExp;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/domain/addressing/grammar/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../../../domain/addressing/grammar/tokens.ts"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,EAAG,GAAY,CAAA;AAEtC;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAG,IAAa,CAAA;AAEzC;;;;GAIG;AACH,eAAO,MAAM,cAAc,QAAiD,CAAA;AAE5E;;;;GAIG;AACH,eAAO,MAAM,cAAc,QAAiD,CAAA"}

package/dist/domain/addressing/grammar/tokens.js

@@ -0,0 +1,34 @@
+// ── Domain-grammar tokens & validators ─────────────────────
+// Lexer-facing vocabulary: separators recognised by the grammar
+// extensions and the regexes used to validate slug bodies during
+// `parseStep`.
+/**
+ * Domain separator — `:` is the universal domain-realm delimiter.
+ *
+ * Positional meaning:
+ * - `:domain`              → installed_in
+ * - `:domain:member`       → installed_in + of_domain
+ * - `:domain:member:method` → installed_in + of_domain + method_of
+ */
+export const DOMAIN_SEP = ':';
+/**
+ * Instance dispatch separator — `::` means instance_of → method_of.
+ *
+ * Used from any node to call a method defined on its type:
+ * - `@instanceId::send`            → instance_of + method_of
+ * - `:messaging:Message::create`   → ... + instance_of + method_of
+ */
+export const INSTANCE_SEP = '::';
+/**
+ * Regex for valid domain names. A domain name is a DNS-like dotted
+ * sequence of slug segments. Looser than tree slugs because dots are
+ * allowed within (e.g., `kernel.astrale.ai`).
+ */
+export const DOMAIN_NAME_RE = /^[a-zA-Z0-9](?:[a-zA-Z0-9._-]*[a-zA-Z0-9])?$/;
+/**
+ * Regex for member slug bodies — class names, interface names, method
+ * names, or qualified forms like `class.Foo` and `interface.Bar`. The
+ * discriminator is the prefix when present, not the regex itself.
+ */
+export const MEMBER_SLUG_RE = /^[a-zA-Z0-9](?:[a-zA-Z0-9._-]*[a-zA-Z0-9])?$/;
+//# sourceMappingURL=tokens.js.map

package/dist/domain/addressing/grammar/tokens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.js","sourceRoot":"","sources":["../../../../domain/addressing/grammar/tokens.ts"],"names":[],"mappings":"AAAA,8DAA8D;AAC9D,gEAAgE;AAChE,iEAAiE;AACjE,eAAe;AAEf;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,GAAY,CAAA;AAEtC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,IAAa,CAAA;AAEzC;;;;GAIG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,8CAA8C,CAAA;AAE5E;;;;GAIG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,8CAA8C,CAAA"}

package/dist/domain/addressing/keys/build.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Build a flat key map from structured refs.
+ * Each ref maps to its globally unique key string: domain:ref.
+ */
+import type { Schema } from '@astrale-os/kernel-dsl';
+import type { DomainRefs } from '#domain/addressing/refs/types';
+import type { DomainOrigin } from '#domain/origin';
+import type { DomainKeysMap } from './types';
+export declare function domainKeys<S extends Schema>(origin: DomainOrigin, refs: DomainRefs<S>): DomainKeysMap<S>;
+//# sourceMappingURL=build.d.ts.map

package/dist/domain/addressing/keys/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../../domain/addressing/keys/build.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAEpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAKlD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAI5C,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EACzC,MAAM,EAAE,YAAY,EACpB,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAClB,aAAa,CAAC,CAAC,CAAC,CAMlB"}

package/dist/domain/addressing/keys/build.js

@@ -0,0 +1,15 @@
+/**
+ * Build a flat key map from structured refs.
+ * Each ref maps to its globally unique key string: domain:ref.
+ */
+import { iterateRefs } from '#domain/addressing/refs/iterate';
+import { Ref } from '#domain/addressing/refs/ref';
+import { Key } from './key';
+export function domainKeys(origin, refs) {
+    const result = {};
+    for (const entry of iterateRefs(refs)) {
+        result[entry.ref] = Key.of(origin, Ref.parse(entry.ref)).toString();
+    }
+    return result;
+}
+//# sourceMappingURL=build.js.map

package/dist/domain/addressing/keys/build.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.js","sourceRoot":"","sources":["../../../../domain/addressing/keys/build.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAA;AAC7D,OAAO,EAAE,GAAG,EAAE,MAAM,6BAA6B,CAAA;AAIjD,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAE3B,MAAM,UAAU,UAAU,CACxB,MAAoB,EACpB,IAAmB;IAEnB,MAAM,MAAM,GAA2B,EAAE,CAAA;IACzC,KAAK,MAAM,KAAK,IAAI,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;QACtC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAA;IACrE,CAAC;IACD,OAAO,MAA0B,CAAA;AACnC,CAAC"}

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

@@ -0,0 +1,4 @@
+export type { DomainKey, DomainKeysMap } from './types';
+export { Key, KeyParseError } from './key';
+export { domainKeys } from './build';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../domain/addressing/keys/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AACvD,OAAO,EAAE,GAAG,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA"}

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

@@ -0,0 +1,3 @@
+export { Key, KeyParseError } from './key';
+export { domainKeys } from './build';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../domain/addressing/keys/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA"}

package/dist/domain/addressing/keys/key.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Key — the globally unique domain address value type.
+ *
+ * A Key identifies an addressable element across all domains:
+ *   'blog.acme.com:class.Author'                    → Key(domain, Ref('class', ['Author']))
+ *   'blog.acme.com:class.Author.method.deactivate'  → Key(domain, Ref('class', ['Author', 'method', 'deactivate']))
+ *   'blog.acme.com:class.Author.property.bio'       → Key(domain, Ref('class', ['Author', 'property', 'bio']))
+ *
+ * This is the SINGLE owner of the ':' separator in domain key strings.
+ * No other module should indexOf(':') or template-literal colon-join to build keys.
+ */
+import type { DomainOrigin } from '#domain/origin';
+import { Ref } from '#domain/addressing/refs/ref';
+export declare class Key {
+    readonly domain: DomainOrigin;
+    readonly ref: Ref;
+    private constructor();
+    /** Create a key from a domain origin and a Ref. */
+    static of(domain: DomainOrigin, ref: Ref): Key;
+    /** Create a key from a domain origin and a ref string. */
+    static fromString(domain: DomainOrigin, refStr: string): Key;
+    /**
+     * Parse a key string into a Key.
+     *
+     * Splits on first ':' → [domain, refString].
+     * Delegates ref parsing to Ref.parse() — the single ref parser.
+     *
+     * @throws RefParseError if the ref portion is malformed.
+     * @throws KeyParseError if the string has no ':' separator.
+     */
+    static parse(raw: string): Key;
+    /** Try to parse — returns null instead of throwing. */
+    static tryParse(raw: string): Key | null;
+    /**
+     * Compose a key string directly, without parsing the ref.
+     *
+     * For hot paths that already hold a trusted ref string and only need the
+     * combined `<domain>:<ref>` form — e.g. cache keys keyed by the same shape
+     * as `toString()` but where paying `Ref.parse` per lookup would be waste.
+     *
+     * The caller is trusted: no validation runs. Use `Key.parse`/`fromString`
+     * when the input is untrusted.
+     */
+    static raw(domain: string, refStr: string): string;
+    /**
+     * The shared prefix of every key belonging to `domain` — i.e. `"<domain>:"`.
+     *
+     * Used for prefix-scan invalidation over Maps keyed by the `raw()` form.
+     */
+    static prefixOf(domain: string): string;
+    get namespace(): import("../namespace").Namespace;
+    get member(): string;
+    /** The child name (method name, property name, etc.) — third segment. */
+    get child(): string | undefined;
+    /** True if this key addresses a method. */
+    get isMethod(): boolean;
+    /** True if this key addresses a property. */
+    get isProperty(): boolean;
+    /** The full key string: 'blog.acme.com:class.Author.method.deactivate'. */
+    toString(): string;
+    /** Equality check. */
+    equals(other: Key): boolean;
+}
+/** Error thrown when a key string cannot be parsed. */
+export declare class KeyParseError extends Error {
+    readonly raw: string;
+    readonly reason: string;
+    constructor(raw: string, reason: string);
+}
+//# sourceMappingURL=key.d.ts.map

package/dist/domain/addressing/keys/key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key.d.ts","sourceRoot":"","sources":["../../../../domain/addressing/keys/key.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAGlD,OAAO,EAAE,GAAG,EAAE,MAAM,6BAA6B,CAAA;AAEjD,qBAAa,GAAG;IACd,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;IAC7B,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;IAEjB,OAAO,eAGN;IAID,mDAAmD;IACnD,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,CAE7C;IAED,0DAA0D;IAC1D,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,GAAG,CAE3D;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAQ7B;IAED,uDAAuD;IACvD,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,GAAG,IAAI,CAMvC;IAID;;;;;;;;;OASG;IACH,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEjD;IAED;;;;OAIG;IACH,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtC;IAID,IAAI,SAAS,qCAEZ;IAED,IAAI,MAAM,WAET;IAED,yEAAyE;IACzE,IAAI,KAAK,uBAER;IAED,2CAA2C;IAC3C,IAAI,QAAQ,YAEX;IAED,6CAA6C;IAC7C,IAAI,UAAU,YAEb;IAID,2EAA2E;IAC3E,QAAQ,IAAI,MAAM,CAEjB;IAED,sBAAsB;IACtB,MAAM,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAE1B;CACF;AAED,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"}

package/dist/domain/addressing/keys/key.js

@@ -0,0 +1,118 @@
+/**
+ * Key — the globally unique domain address value type.
+ *
+ * A Key identifies an addressable element across all domains:
+ *   'blog.acme.com:class.Author'                    → Key(domain, Ref('class', ['Author']))
+ *   'blog.acme.com:class.Author.method.deactivate'  → Key(domain, Ref('class', ['Author', 'method', 'deactivate']))
+ *   'blog.acme.com:class.Author.property.bio'       → Key(domain, Ref('class', ['Author', 'property', 'bio']))
+ *
+ * This is the SINGLE owner of the ':' separator in domain key strings.
+ * No other module should indexOf(':') or template-literal colon-join to build keys.
+ */
+import { DOMAIN_SEP } from '#domain/addressing/grammar/tokens';
+import { Ref } from '#domain/addressing/refs/ref';
+export class Key {
+    domain;
+    ref;
+    constructor(domain, ref) {
+        this.domain = domain;
+        this.ref = ref;
+    }
+    // ── Factories ──────────────────────────────────────────────────────
+    /** Create a key from a domain origin and a Ref. */
+    static of(domain, ref) {
+        return new Key(domain, ref);
+    }
+    /** Create a key from a domain origin and a ref string. */
+    static fromString(domain, refStr) {
+        return new Key(domain, Ref.parse(refStr));
+    }
+    /**
+     * Parse a key string into a Key.
+     *
+     * Splits on first ':' → [domain, refString].
+     * Delegates ref parsing to Ref.parse() — the single ref parser.
+     *
+     * @throws RefParseError if the ref portion is malformed.
+     * @throws KeyParseError if the string has no ':' separator.
+     */
+    static parse(raw) {
+        const colonIdx = raw.indexOf(':');
+        if (colonIdx === -1)
+            throw new KeyParseError(raw, 'missing domain separator');
+        const domain = raw.slice(0, colonIdx);
+        const refStr = raw.slice(colonIdx + 1);
+        return new Key(domain, Ref.parse(refStr));
+    }
+    /** Try to parse — returns null instead of throwing. */
+    static tryParse(raw) {
+        try {
+            return Key.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    // ── String builders (skip parsing) ─────────────────────────────────
+    /**
+     * Compose a key string directly, without parsing the ref.
+     *
+     * For hot paths that already hold a trusted ref string and only need the
+     * combined `<domain>:<ref>` form — e.g. cache keys keyed by the same shape
+     * as `toString()` but where paying `Ref.parse` per lookup would be waste.
+     *
+     * The caller is trusted: no validation runs. Use `Key.parse`/`fromString`
+     * when the input is untrusted.
+     */
+    static raw(domain, refStr) {
+        return `${domain}${DOMAIN_SEP}${refStr}`;
+    }
+    /**
+     * The shared prefix of every key belonging to `domain` — i.e. `"<domain>:"`.
+     *
+     * Used for prefix-scan invalidation over Maps keyed by the `raw()` form.
+     */
+    static prefixOf(domain) {
+        return `${domain}${DOMAIN_SEP}`;
+    }
+    // ── Delegated accessors ────────────────────────────────────────────
+    get namespace() {
+        return this.ref.namespace;
+    }
+    get member() {
+        return this.ref.member;
+    }
+    /** The child name (method name, property name, etc.) — third segment. */
+    get child() {
+        return this.ref.child;
+    }
+    /** True if this key addresses a method. */
+    get isMethod() {
+        return this.ref.isMethod;
+    }
+    /** True if this key addresses a property. */
+    get isProperty() {
+        return this.ref.isProperty;
+    }
+    // ── String representation ─────────────────────────────────────────
+    /** The full key string: 'blog.acme.com:class.Author.method.deactivate'. */
+    toString() {
+        return Key.raw(this.domain, this.ref.toString());
+    }
+    /** Equality check. */
+    equals(other) {
+        return this.domain === other.domain && this.ref.equals(other.ref);
+    }
+}
+/** Error thrown when a key string cannot be parsed. */
+export class KeyParseError extends Error {
+    raw;
+    reason;
+    constructor(raw, reason) {
+        super(`Invalid key "${raw}": ${reason}`);
+        this.name = 'KeyParseError';
+        this.raw = raw;
+        this.reason = reason;
+    }
+}
+//# sourceMappingURL=key.js.map

package/dist/domain/addressing/keys/key.js.map

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

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

@@ -0,0 +1,28 @@
+import type { Schema } from '@astrale-os/kernel-dsl';
+import type { DomainOrigin } from '#domain/origin';
+/**
+ * A globally unique domain key string: 'domain:ref'.
+ *
+ * Parameterized on `Ref` so typed ref entries (e.g. `K.Named.name.key`) can
+ * carry the specific ref literal through `.key`, which in turn lets callers
+ * use that value as a computed key on a typed draft (see PropsOf's
+ * qualified-ref shape). Defaults to `string` when used as a plain value
+ * type in runtime APIs.
+ *
+ * @example
+ *   'blog.acme.com:class.Author'                           // DomainKey
+ *   'blog.acme.com:interface.Named.property.name'          // DomainKey<'interface.Named.property.name'>
+ *   'blog.acme.com:core.alice'                             // DomainKey<'core.alice'>
+ */
+export type DomainKey<Ref extends string = string> = `${DomainOrigin}:${Ref}`;
+/**
+ * Flat key map: ref.toString() → globally unique DomainKey string.
+ *
+ * @example
+ *   keys['class.Author']            → 'blog.acme.com:class.Author'
+ *   keys['class.Author.deactivate'] → 'blog.acme.com:class.Author.deactivate'
+ */
+export type DomainKeysMap<S extends Schema = Schema> = {
+    readonly [K: string]: `${S['domain']}:${string}`;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../domain/addressing/keys/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAElD;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,SAAS,CAAC,GAAG,SAAS,MAAM,GAAG,MAAM,IAAI,GAAG,YAAY,IAAI,GAAG,EAAE,CAAA;AAE7E;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI;IACrD,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC,CAAC,QAAQ,CAAC,IAAI,MAAM,EAAE,CAAA;CACjD,CAAA"}

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

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

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

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

package/dist/domain/addressing/layout/build.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Default tree layout for a domain.
+ *
+ * Maps refs to AbsolutePaths using the DomainPaths convention:
+ *   class.Author            → /origin/class.Author/self
+ *   class.Author.method.x   → /origin/class.Author/x
+ *   interface.Named         → /origin/interface.Named/self
+ *   core.alice              → /origin/core/alice
+ *   core.posts.laptop       → /origin/core/posts/laptop
+ */
+import type { DomainOrigin } from '#domain/origin';
+import type { Layout } from './types';
+/**
+ * Create the default layout resolver for a domain.
+ *
+ * Uses the DomainPaths convention. Pass the returned Layout
+ * to `buildStructuredRefs` or `compileDomain`.
+ */
+export declare function defaultLayout(origin: DomainOrigin): Layout;
+//# sourceMappingURL=build.d.ts.map

package/dist/domain/addressing/layout/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../../domain/addressing/layout/build.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAElD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAIrC;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAa1D"}

package/dist/domain/addressing/layout/build.js

@@ -0,0 +1,33 @@
+/**
+ * Default tree layout for a domain.
+ *
+ * Maps refs to AbsolutePaths using the DomainPaths convention:
+ *   class.Author            → /origin/class.Author/self
+ *   class.Author.method.x   → /origin/class.Author/x
+ *   interface.Named         → /origin/interface.Named/self
+ *   core.alice              → /origin/core/alice
+ *   core.posts.laptop       → /origin/core/posts/laptop
+ */
+import { DomainPaths } from './default';
+/**
+ * Create the default layout resolver for a domain.
+ *
+ * Uses the DomainPaths convention. Pass the returned Layout
+ * to `buildStructuredRefs` or `compileDomain`.
+ */
+export function defaultLayout(origin) {
+    const dp = new DomainPaths(origin);
+    return (ref) => {
+        if (ref.isMethod)
+            return dp.method(ref.qualified, ref.child);
+        switch (ref.namespace) {
+            case 'interface':
+                return dp.interface(ref.member);
+            case 'core':
+                return dp.coreAnchor().append(...ref.member.split('.'));
+            default:
+                return dp.class(ref.member);
+        }
+    };
+}
+//# sourceMappingURL=build.js.map

package/dist/domain/addressing/layout/build.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.js","sourceRoot":"","sources":["../../../../domain/addressing/layout/build.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAEvC;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,MAAoB;IAChD,MAAM,EAAE,GAAG,IAAI,WAAW,CAAC,MAAM,CAAC,CAAA;IAClC,OAAO,CAAC,GAAG,EAAE,EAAE;QACb,IAAI,GAAG,CAAC,QAAQ;YAAE,OAAO,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,GAAG,CAAC,KAAM,CAAC,CAAA;QAC7D,QAAQ,GAAG,CAAC,SAAS,EAAE,CAAC;YACtB,KAAK,WAAW;gBACd,OAAO,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;YACjC,KAAK,MAAM;gBACT,OAAO,EAAE,CAAC,UAAU,EAAE,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAA;YACzD;gBACE,OAAO,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;QAC/B,CAAC;IACH,CAAC,CAAA;AACH,CAAC"}

package/dist/domain/addressing/layout/default.d.ts

@@ -0,0 +1,67 @@
+/**
+ * DomainPaths — the default tree layout convention.
+ *
+ * Maps domain refs to AbsolutePaths in the navigation tree:
+ *
+ *   /<origin>                           — Domain node
+ *   /<origin>/class.Author              — Folder node (namespace.TypeName)
+ *   /<origin>/class.Author/self         — Class self node
+ *   /<origin>/class.Author/deactivate   — Function (method) node
+ *   /<origin>/interface.Named           — Folder node
+ *   /<origin>/interface.Named/self      — Interface self node
+ *   /<origin>/core                      — User core anchor (kernel Folder)
+ *   /<origin>/core/alice                — Core instance node
+ *
+ * Schema folder slugs use namespace prefix (class./interface.). The user
+ * core lives under a reserved single-segment anchor `core` — this gives a
+ * purely structural discrimination at deserialize time.
+ */
+import { CORE_ANCHOR_SLUG } from '@astrale-os/kernel-dsl';
+import type { DomainOrigin } from '#domain/origin';
+import { AbsolutePath } from '#graph/tree';
+export { CORE_ANCHOR_SLUG };
+export declare class DomainPaths {
+    readonly origin: DomainOrigin;
+    private readonly _root;
+    private readonly _corePrefix;
+    constructor(origin: DomainOrigin);
+    /** Convenience factory from a raw string. */
+    static of(origin: string): DomainPaths;
+    /** The domain root node: `/<origin>` */
+    root(): AbsolutePath;
+    /** Folder node: `/<origin>/class.{Name}` or `/<origin>/interface.{Name}` */
+    folder(ref: string): AbsolutePath;
+    /** Class self node: `/<origin>/class.{Name}/self` */
+    class(name: string): AbsolutePath;
+    /** Interface self node: `/<origin>/interface.{Name}/self` */
+    interface(name: string): AbsolutePath;
+    /** Function (method) node: `/<origin>/{namespace}.{TypeName}/{methodName}` */
+    method(folderRef: string, methodName: string): AbsolutePath;
+    /** User core anchor folder: `/<origin>/core` */
+    coreAnchor(): AbsolutePath;
+    /**
+     * Convert a builder CorePath raw string to a graph AbsolutePath. The builder
+     * already embeds the `core/` anchor segment, so this is a direct mapping.
+     *
+     * `/<origin>/core/alice` → `/<origin>/core/alice`
+     * `/<origin>/core/posts/laptop` → `/<origin>/core/posts/laptop`
+     */
+    corePath(raw: string): AbsolutePath;
+    /**
+     * Extract a domain-relative ref from a builder CorePath raw string. Strips
+     * the `/<origin>/core/` prefix and joins slugs with dots.
+     *
+     * `/blog.acme.com/core/alice` → `alice`
+     * `/blog.acme.com/core/electronics/laptop` → `electronics.laptop`
+     */
+    coreRef(raw: string): string;
+    private assertAnchoredPath;
+    /**
+     * Extract the type name from a self node path.
+     * Self path shape: `/<domain>/<namespace.Name>/self` — returns the namespace.Name slug.
+     */
+    static parseTypeName(path: AbsolutePath): string | undefined;
+    /** True if the path ends with `/self`. */
+    static isSelfNode(path: AbsolutePath): boolean;
+}
+//# sourceMappingURL=default.d.ts.map

package/dist/domain/addressing/layout/default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../../../domain/addressing/layout/default.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAEzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAGlD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAI1C,OAAO,EAAE,gBAAgB,EAAE,CAAA;AAE3B,qBAAa,WAAW;IACtB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;IAC7B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;IACpC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAQ;IAEpC,YAAY,MAAM,EAAE,YAAY,EAI/B;IAED,6CAA6C;IAC7C,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAErC;IAID,wCAAwC;IACxC,IAAI,IAAI,YAAY,CAEnB;IAID,4EAA4E;IAC5E,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAEhC;IAED,qDAAqD;IACrD,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAEhC;IAED,6DAA6D;IAC7D,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAEpC;IAED,8EAA8E;IAC9E,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,YAAY,CAE1D;IAID,gDAAgD;IAChD,UAAU,IAAI,YAAY,CAEzB;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAGlC;IAED;;;;;;OAMG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG3B;IAED,OAAO,CAAC,kBAAkB;IAW1B;;;OAGG;IACH,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,GAAG,SAAS,CAI3D;IAED,0CAA0C;IAC1C,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAE7C;CACF"}