@astrale-os/kernel-core 0.4.1

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

@@ -0,0 +1,319 @@
+import type { ExtractProperties, InferProperties, Schema } from '@astrale-os/kernel-dsl';
+import type { ClassPath } from '#domain/addressing/paths';
+import type { Node } from '#graph';
+import type { Path } from '#graph/nav/path';
+import type { TreePath } from '#graph/tree';
+import type { AbsolutePath } from '#graph/tree';
+import type { NodeId } from '#ids';
+/**
+ * Adapter contract for method dispatch — provided by the consumer
+ * (shell, CLI, SDK, tests). The accessor wraps each method in a
+ * closure that calls through this function.
+ */
+export type MethodDispatch = (nodeId: NodeId, methodRef: string, args: unknown) => Promise<unknown>;
+/** Domain-keyed grouped properties: domain → InterfaceName → propName → value. */
+export type GroupedProps = Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, unknown>>>>>>;
+/**
+ * Write-side grouped properties — mutable counterpart to GroupedProps.
+ * Same shape; this alias exists for call sites that construct write payloads.
+ */
+export type Properties = Record<string, Record<string, Record<string, unknown>>>;
+/** Class-own attributes (flat record). */
+export type Attributes = Readonly<Record<string, unknown>>;
+/** Flat user-facing property record — bare keys (`title`) or qualified (`Named.name`). */
+export type FlatProperties = Readonly<Record<string, unknown>>;
+/** Discriminated union returned by `validate()` / `qualify()` — either the value or the errors. */
+export type Result<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly errors: readonly ValidationError[];
+};
+/** One per-field validation failure. Extensible kind taxonomy. */
+export interface ValidationError {
+    readonly key: string;
+    readonly message: string;
+    readonly kind: 'unknown-key' | 'ambiguous-key' | 'unknown-class' | 'missing-required';
+}
+/**
+ * Qualify each key of a property record with an `Owner.` prefix.
+ *
+ * Used to surface the runtime's owner-disambiguation form (`'Named.name'`)
+ * in the inferred draft shape. Pure key-remap — value types are preserved.
+ */
+type QualifyOne<Owner extends string, A> = {
+    [K in keyof InferProperties<A> & string as `${Owner}.${K}`]: InferProperties<A>[K];
+};
+/**
+ * Qualify each key of a property record with a `Domain:Owner.` prefix —
+ * the fully-disambiguated form that mirrors the runtime's storage key shape
+ * (`'kernel.astrale.ai:Named.name'`). Pure key-remap.
+ */
+type DomainQualifyOne<Domain extends string, Owner extends string, A> = {
+    [K in keyof InferProperties<A> & string as `${Domain}:${Owner}.${K}`]: InferProperties<A>[K];
+};
+/**
+ * Standard `UnionToIntersection` — collapses a union of records into a single
+ * intersected record. Bounded cost; canonical TS pattern via contravariant
+ * positions. Used to merge per-interface qualified-key records into one
+ * flat shape.
+ */
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * Interface map for qualified-key inference — own interfaces only.
+ *
+ * Previously walked `S['imports']` at the type level to pick up imported
+ * interfaces (`Named`, `Timestamped`, etc.) for qualified keys like
+ * `'Named.name'`. That walk required the `Imports` generic on `Schema` to
+ * preserve concrete import types, which triggered TS7056 declaration-emit
+ * blowup on moderately sized domains (see docs/specs/schema-type-inference-size.md).
+ *
+ * Now `imports` is runtime-only. Consumers that use imported interfaces via
+ * qualified keys lose type-level autocomplete on those keys; the runtime
+ * still accepts them. The domain-qualified form (`'kernel.astrale.ai:Named.name'`)
+ * is the escape hatch for cross-schema typing.
+ */
+type AllInterfaces<S extends Schema> = S['interfaces'];
+/**
+ * Qualified keys for every interface in scope (own + imported) — `Iface.prop`
+ * for each (Iface, prop) pair. Deliberately over-permissive: it does NOT
+ * filter to interfaces actually inherited by class `C`, so callers can
+ * type `'OtherIface.prop'` on the wrong class. The runtime's
+ * `groupProperties` rejects those at write time with `UnknownPropertyError`.
+ */
+type AllInterfaceQualified<S extends Schema> = UnionToIntersection<{
+    [I in keyof AllInterfaces<S> & string]: QualifyOne<I, ExtractProperties<AllInterfaces<S>[I]>>;
+}[keyof AllInterfaces<S> & string]>;
+/**
+ * Domain-qualified keys for every interface in scope — `Domain:Iface.prop`.
+ *
+ * Own interfaces tagged with `S['domain']`. Imported interfaces tagged with
+ * the domain of the schema that exports them. The runtime accepts this form
+ * via `groupProperties`'s colon-split path; lookup currently uses owner only,
+ * so the domain prefix is decorative until the property index is keyed by
+ * `(domain, ownerName)`. See accessors/group.ts for the parser.
+ */
+type AllDomainQualified<S extends Schema> = UnionToIntersection<{
+    [I in keyof S['interfaces'] & string]: DomainQualifyOne<S['domain'] & string, I, ExtractProperties<S['interfaces'][I]>>;
+}[keyof S['interfaces'] & string]>;
+/**
+ * Fully-qualified ref keys — mirrors the value type of `K.<Owner>.<prop>.key`
+ * (`<Domain>:interface.<Iface>.property.<prop>` /
+ * `<Domain>:class.<Class>.property.<prop>`), the 4th grammar shape parsed by
+ * `parsePropertyShortcut` ('qualified').
+ *
+ * Exists so typed computed-key usage compiles on the strict draft channel:
+ *
+ *   K.$.draft('Interface', { [K.Named.name.key]: params.name }, path)
+ *
+ * The ref-entry `.key` types carry the specific ref literal through
+ * `DomainKey<Ref>`, producing a pattern template (`${string}:interface.Named.property.name`).
+ * This shape matches that pattern so the computed key survives without
+ * widening the draft object to an unrelated index signature.
+ */
+type QualifiedRefOne<Domain extends string, Prefix extends string, A> = {
+    [K in keyof InferProperties<A> & string as `${Domain}:${Prefix}.property.${K}`]: InferProperties<A>[K];
+};
+type AllQualifiedRefs<S extends Schema, C extends keyof S['classes']> = UnionToIntersection<{
+    [I in keyof S['interfaces'] & string]: QualifiedRefOne<S['domain'] & string, `interface.${I}`, ExtractProperties<S['interfaces'][I]>>;
+}[keyof S['interfaces'] & string] | QualifiedRefOne<S['domain'] & string, `class.${C & string}`, ExtractProperties<S['classes'][C]>>>;
+/**
+ * Flat prop shape for a specific class — inferred from the schema.
+ *
+ * Five accepted key shapes:
+ * - **bare** — `'color'` — class-own props only. Inherited interface props
+ *   MUST be qualified.
+ * - **class-qualified** — `'Tag.color'` — same as bare, but explicit.
+ * - **interface-qualified** — `'Named.name'` — for inherited interface props.
+ *   Throws `AmbiguousOwnerAcrossDomainsError` at write time if `Named` is
+ *   imported from two domains; escalate to the domain-qualified form.
+ * - **domain-qualified** — `'kernel.astrale.ai:Named.name'` — fully
+ *   disambiguated. Mirrors one runtime storage key shape.
+ * - **qualified-ref** — `'kernel.astrale.ai:interface.Named.property.name'`
+ *   (or `'...:class.Author.property.bio'`). The same shape produced by
+ *   `K.<Owner>.<prop>.key`, so typed accessors drop straight into computed
+ *   keys: `{ [K.Named.name.key]: value }`.
+ *
+ * Why no bare keys for inherited props? Bare-key resolution required a
+ * runtime `findOwner` pass that conflated class-own and inherited props,
+ * silently picked one on collision, and forced the type system to walk the
+ * full ancestor chain. Restricting bare to class-own makes the contract
+ * `bare = mine, qualified = inherited` and drops `ExtractFullProperties`
+ * (the heaviest type in the inference chain) from this definition.
+ *
+ * All keys are optional: drafts double as create *and* update payloads,
+ * and the runtime auto-stamps several fields (`createdAt`, `updatedAt`,
+ * `status`) that callers can't meaningfully supply anyway. Required vs
+ * optional is enforced by the runtime validator, not the inferred shape.
+ */
+export type PropsOf<S extends Schema, C extends keyof S['classes']> = Partial<InferProperties<ExtractProperties<S['classes'][C]>> & QualifyOne<C & string, ExtractProperties<S['classes'][C]>> & AllInterfaceQualified<S> & AllDomainQualified<S> & AllQualifiedRefs<S, C>>;
+/** Node draft shape returned by `draft()` — ready to pass to mutation APIs. */
+export interface NodeDraft {
+    readonly class: ClassPath;
+    readonly path?: TreePath;
+    readonly props: Record<string, unknown>;
+}
+/**
+ * Edge draft shape returned by `draftEdge()` — ready to pass to `createEdge`.
+ *
+ * Mirrors the node draft but carries the edge's structural fields (`source`,
+ * `target`, `slug`) instead of a tree `path`. Props flow through the same
+ * qualify pipeline as node drafts when the mutation backend runs.
+ */
+export interface EdgeDraft {
+    readonly class: ClassPath;
+    readonly source: Path;
+    readonly target: Path;
+    readonly slug?: string;
+    readonly props: Record<string, unknown>;
+}
+/**
+ * Per-interface inferred prop bag — mirrors `node.Named` shape (the keys
+ * and value types that `Named` declares as its own properties).
+ */
+type InterfaceBag<I> = InferProperties<ExtractProperties<I>>;
+/**
+ * Top-level interface bags for every interface in scope (own + imported).
+ * Over-permissive in the same spirit as `AllInterfaceQualified`: allows
+ * `node.OtherInterface.prop` for interfaces this class doesn't actually
+ * inherit. Runtime catches misses; the trade keeps inference cheap.
+ */
+type AllInterfaceBags<S extends Schema> = {
+    [I in keyof AllInterfaces<S> & string]: Readonly<InterfaceBag<AllInterfaces<S>[I]>>;
+};
+/**
+ * A node wrapped for rich, typed property access.
+ *
+ * Identity lives at the top level and cannot be shadowed by domain-defined
+ * properties — `id`, `path`, `class` are typed, required, and disjoint from
+ * the property groups below. Data lives behind explicit groups:
+ *
+ * - `node.attrs.wordCount`                        — class-own attributes
+ * - `node.Named.name`                             — interface sugar (unambiguous)
+ * - `node.publish(args)`                          — method callable (when dispatch is wired)
+ * - `node.$d('kernel.astrale.ai').Named.name`     — fully qualified escape hatch
+ *
+ * Ambiguous top-level interface or method access throws at read time —
+ * see `AmbiguousInterfaceError` / `AmbiguousMethodError`.
+ *
+ * Always typed: there is no untyped fallback. Callers that don't have a
+ * concrete class name should work with the raw `Node` object directly —
+ * the accessor wrapping is only valuable when paired with a class. Both
+ * generics carry meaningful type information into `attrs` and interface
+ * bags, so leaving them defaulted produces a degenerate (mostly empty)
+ * shape — which is the right signal that wrap was the wrong tool.
+ */
+export type AccessorNode<S extends Schema = Schema, N extends keyof S['classes'] & string = keyof S['classes'] & string> = {
+    readonly id: NodeId;
+    readonly path: AbsolutePath;
+    readonly class: ClassPath;
+    /** Class-own attribute bag — typed by the class definition's properties. */
+    readonly attrs: Readonly<InferProperties<ExtractProperties<S['classes'][N]>>>;
+    /** Domain-disambiguating escape hatch — see schema validation warnings. */
+    $d(domain: string): Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+} & Partial<AllInterfaceBags<S>>;
+/**
+ * The accessor surface bound on a CompiledDomain.
+ *
+ * Single implementation shared by `compile` (source → CompiledDomain) and
+ * `deserialize-from-graph` (graph → CompiledDomain), so both paths produce
+ * the same wrapper behavior.
+ *
+ * The optional `S` generic carries the source schema type, enabling typed
+ * `draft<N>()` and a path toward typed `wrap`/`validate` in the future.
+ * Defaults to `Schema` so existing untyped call sites keep working.
+ */
+export interface BoundAccessorMethods<S extends Schema = Schema> {
+    /**
+     * Wrap a materialized node into an AccessorNode view. Two shapes:
+     *
+     * `wrap(node, dispatch?)` — className inferred from `node.class.className`.
+     * Returns the widened `AccessorNode<S>`; useful when the class isn't known
+     * statically (dynamic dispatch, generic graph tooling).
+     *
+     * `wrap('Tag', node, dispatch?)` — className asserted. Returns the narrowed
+     * `AccessorNode<S, 'Tag'>`, so `attrs` is typed by the class's own props
+     * and interface bags are typed across the schema. A mismatch between the
+     * declared class and `node.class.className` throws at runtime.
+     *
+     * Common rules for both forms:
+     * - `node.class.domain` must match the accessor's bound origin, else throws.
+     * - Optional `dispatch` wires method callables; omit for pure data access
+     *   (e.g. inside a method handler, where re-entrant self-dispatch is a
+     *   footgun).
+     * - No validation runs — the graph is the trust boundary. Reading back is
+     *   a zero-overhead structural transform.
+     */
+    wrap(node: Node, dispatch?: MethodDispatch): AccessorNode<S>;
+    wrap<N extends keyof S['classes'] & string>(className: N, node: Node, dispatch?: MethodDispatch): AccessorNode<S, N>;
+    /**
+     * Pure check — does this draft's `props` pass validation?
+     *
+     * Reports every per-field failure (collected, not first-fail) so form UIs
+     * can highlight all errors at once. Does NOT transform the draft; use
+     * `qualify()` when you need the canonical storage form.
+     */
+    validate<T extends {
+        class: ClassPath;
+        props?: FlatProperties;
+    }>(draft: T): Result<void>;
+    /**
+     * Validate-and-transform — returns the draft with `props` rewritten to the
+     * canonical qualified storage form (`<domain>:interface.X.property.Y`).
+     *
+     * The generic preserves the draft shape: pass a node draft, get a node
+     * draft back; pass an edge draft with `source`/`target`, get the same
+     * shape back. Only the `props` field is transformed when `ok`.
+     *
+     * Write-path callers (graph runtime) check `!result.ok` and throw with
+     * the full error list. Call sites bypassing the port call this directly
+     * to qualify before handing off to the mutation backend.
+     */
+    qualify<T extends {
+        class: ClassPath;
+        props?: FlatProperties;
+    }>(draft: T, options?: {
+        partial?: boolean;
+    }): Result<T & {
+        props: FlatProperties;
+    }>;
+    /**
+     * Typed draft builder — given a class name and props, build a NodeDraft
+     * ready for `qualify()` or `graph.*` mutation APIs (which qualify
+     * internally). Pure type carrier at runtime; the prop type is inferred
+     * from `S['classes'][N]` when `S` is provided.
+     *
+     * When the accessor is bound without a typed schema (`S = Schema`), this
+     * degrades to accepting any `FlatProperties` shape.
+     *
+     * Overloaded so callers that supply a `path` get a narrowed return type —
+     * `P` preserves whatever subtype of `TreePath` was passed (`AbsolutePath`,
+     * `TreePath`, etc.) so the draft drops straight into mutation signatures
+     * like `createNode({ path: AbsolutePath })` without a widening cast.
+     * Without a `path`, the return stays spec-shaped (`path?: TreePath`) for
+     * sync/compose-later flows.
+     */
+    draft<N extends keyof S['classes'] & string, P extends TreePath>(className: N, props: PropsOf<S, N>, path: P): NodeDraft & {
+        path: P;
+    };
+    draft<N extends keyof S['classes'] & string>(className: N, props: PropsOf<S, N>): NodeDraft;
+    /**
+     * Typed edge draft builder — given an edge class name and params, build an
+     * EdgeDraft ready for `graph.createEdge`. Props are inferred from
+     * `S['classes'][N]` when `S` is provided; without a typed schema, degrades
+     * to accepting any `FlatProperties` shape.
+     *
+     * `slug` is the structural slug used by the path compiler (see
+     * `GraphMutationPort.createEdge`). Omit when the edge class doesn't require
+     * slug-predicate traversal.
+     */
+    draftEdge<N extends keyof S['classes'] & string>(className: N, params: {
+        source: Path;
+        target: Path;
+        slug?: string;
+        props?: PropsOf<S, N>;
+    }): EdgeDraft;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

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

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

package/dist/domain/accessors/types.js

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

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

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

package/dist/domain/addressing/edges.d.ts

@@ -0,0 +1,9 @@
+/** Edge linking a domain node to its installation location. */
+export declare const INSTALLED_IN: 'installed_in';
+/** Edge linking a domain member (class, interface, etc.) to its domain. */
+export declare const OF_DOMAIN: 'of_domain';
+/** Edge linking a method (Function node) to its owning type. */
+export declare const METHOD_OF: 'method_of';
+/** Edge linking an instance to its class. */
+export declare const INSTANCE_OF: 'instance_of';
+//# sourceMappingURL=edges.d.ts.map

package/dist/domain/addressing/edges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edges.d.ts","sourceRoot":"","sources":["../../../domain/addressing/edges.ts"],"names":[],"mappings":"AAKA,+DAA+D;AAC/D,eAAO,MAAM,YAAY,EAAG,cAAuB,CAAA;AAEnD,2EAA2E;AAC3E,eAAO,MAAM,SAAS,EAAG,WAAoB,CAAA;AAE7C,gEAAgE;AAChE,eAAO,MAAM,SAAS,EAAG,WAAoB,CAAA;AAE7C,6CAA6C;AAC7C,eAAO,MAAM,WAAW,EAAG,aAAsB,CAAA"}

package/dist/domain/addressing/edges.js

@@ -0,0 +1,13 @@
+// ── Domain edge-type names ─────────────────────────────────
+// Graph edge identifiers that the domain-addressing layer hops on.
+// Used by `segments/` (graph walks), `grammar/` (slug-to-edge
+// mapping), and the path types (slug-discriminator semantics).
+/** Edge linking a domain node to its installation location. */
+export const INSTALLED_IN = 'installed_in';
+/** Edge linking a domain member (class, interface, etc.) to its domain. */
+export const OF_DOMAIN = 'of_domain';
+/** Edge linking a method (Function node) to its owning type. */
+export const METHOD_OF = 'method_of';
+/** Edge linking an instance to its class. */
+export const INSTANCE_OF = 'instance_of';
+//# sourceMappingURL=edges.js.map

package/dist/domain/addressing/edges.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"edges.js","sourceRoot":"","sources":["../../../domain/addressing/edges.ts"],"names":[],"mappings":"AAAA,8DAA8D;AAC9D,mEAAmE;AACnE,8DAA8D;AAC9D,+DAA+D;AAE/D,+DAA+D;AAC/D,MAAM,CAAC,MAAM,YAAY,GAAG,cAAuB,CAAA;AAEnD,2EAA2E;AAC3E,MAAM,CAAC,MAAM,SAAS,GAAG,WAAoB,CAAA;AAE7C,gEAAgE;AAChE,MAAM,CAAC,MAAM,SAAS,GAAG,WAAoB,CAAA;AAE7C,6CAA6C;AAC7C,MAAM,CAAC,MAAM,WAAW,GAAG,aAAsB,CAAA"}

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

@@ -0,0 +1,16 @@
+import type { GrammarExtension } from '#graph/nav/grammar';
+/**
+ * Domain sugar: `:<domain-name>`.
+ *
+ * Emits one inbound `installed_in` traversal keyed by the domain's
+ * `slug` property. Composes with the absolute scheme — the absolute
+ * grammar consumes the leading `/` (yielding any preceding tree path),
+ * then this grammar picks up the `:domain` tail.
+ *
+ * The domain name regex is intentionally permissive (dots allowed) to
+ * accept DNS-like names (`kernel.astrale.ai`). Slug regex of the tree
+ * scheme rejects dots, so the two grammars can't accidentally claim
+ * the same input.
+ */
+export declare const domainGrammar: GrammarExtension;
+//# sourceMappingURL=domain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"domain.d.ts","sourceRoot":"","sources":["../../../../domain/addressing/grammar/domain.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAmB,MAAM,oBAAoB,CAAA;AAS3E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,EAAE,gBA4D3B,CAAA"}

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

@@ -0,0 +1,92 @@
+import { SLUG_PROPERTY } from '#graph/nav/ast/slug';
+import { INBOUND } from '#graph/nav/path/step';
+import { INSTALLED_IN, METHOD_OF, OF_DOMAIN } from '../edges';
+import { DOMAIN_NAME_RE, DOMAIN_SEP, MEMBER_SLUG_RE } from './tokens';
+/**
+ * Domain sugar: `:<domain-name>`.
+ *
+ * Emits one inbound `installed_in` traversal keyed by the domain's
+ * `slug` property. Composes with the absolute scheme — the absolute
+ * grammar consumes the leading `/` (yielding any preceding tree path),
+ * then this grammar picks up the `:domain` tail.
+ *
+ * The domain name regex is intentionally permissive (dots allowed) to
+ * accept DNS-like names (`kernel.astrale.ai`). Slug regex of the tree
+ * scheme rejects dots, so the two grammars can't accidentally claim
+ * the same input.
+ */
+export const domainGrammar = {
+    name: 'domain',
+    tokens: [{ chars: DOMAIN_SEP, kind: 'DOMAIN_SEP', priority: 0 }],
+    parseStep(stream) {
+        const head = stream.peek();
+        if (!head || head.kind !== 'DOMAIN_SEP')
+            return null;
+        const mark = stream.mark();
+        stream.advance(); // consume ':'
+        const name = stream.peek();
+        if (!name || name.kind !== 'TEXT' || !DOMAIN_NAME_RE.test(name.value)) {
+            stream.restore(mark);
+            return null;
+        }
+        stream.advance();
+        const out = [slugTraversal(INSTALLED_IN, name.value)];
+        // Optional `:member` continuation (one or more chained `:` segments).
+        // Each subsequent `:` walks one edge: `of_domain` for the first
+        // continuation (the class/interface member); `method_of` for the
+        // second (the method on that member).
+        let edgeForNext = OF_DOMAIN;
+        while (stream.peek()?.kind === 'DOMAIN_SEP') {
+            const chainMark = stream.mark();
+            stream.advance(); // consume ':'
+            const member = stream.peek();
+            if (!member || member.kind !== 'TEXT' || !MEMBER_SLUG_RE.test(member.value)) {
+                stream.restore(chainMark);
+                break;
+            }
+            stream.advance();
+            out.push(slugTraversal(edgeForNext, member.value));
+            if (edgeForNext === OF_DOMAIN)
+                edgeForNext = METHOD_OF;
+            else
+                break; // method_of is terminal — no more chain segments
+        }
+        return out;
+    },
+    serializeStep(step) {
+        if (step.kind !== 'traversal')
+            return null;
+        if (step.from !== INBOUND.from || step.to !== INBOUND.to)
+            return null;
+        const p = step.predicate;
+        if (!p || p.kind !== 'property' || p.scope !== 'edge' || p.property !== SLUG_PROPERTY) {
+            return null;
+        }
+        if (step.edgeClass === INSTALLED_IN) {
+            // Emit `/:<value>`. The leading `/` is the separator between any
+            // preceding tree-mount slugs and the domain chain; for a
+            // root-mounted domain path it acts as the absolute prefix
+            // (`/:my-domain` instead of `:my-domain`).
+            return `/${DOMAIN_SEP}${p.value}`;
+        }
+        if (step.edgeClass === OF_DOMAIN || step.edgeClass === METHOD_OF) {
+            return `${DOMAIN_SEP}${p.value}`;
+        }
+        return null;
+    },
+};
+function slugTraversal(edgeClass, value) {
+    return {
+        kind: 'traversal',
+        edgeClass,
+        ...INBOUND,
+        predicate: {
+            kind: 'property',
+            scope: 'edge',
+            property: SLUG_PROPERTY,
+            op: '=',
+            value,
+        },
+    };
+}
+//# sourceMappingURL=domain.js.map

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

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

package/dist/domain/addressing/grammar/instance-method.d.ts

@@ -0,0 +1,14 @@
+import type { GrammarExtension } from '#graph/nav/grammar';
+/**
+ * Instance-dispatch sugar: `::<method>`.
+ *
+ * Emits two steps (the universal "::" tail):
+ *   1. `instance_of` OUTBOUND  — walker at instance, moves to its type.
+ *   2. `method_of`   INBOUND   — walker at the type, moves to the method.
+ *
+ * The `::` token is registered with priority `1` so it beats the
+ * domain `:` token at the lexer (a longer match by length wins after
+ * priority, but explicit priority documents intent).
+ */
+export declare const instanceMethodGrammar: GrammarExtension;
+//# sourceMappingURL=instance-method.d.ts.map

package/dist/domain/addressing/grammar/instance-method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-method.d.ts","sourceRoot":"","sources":["../../../../domain/addressing/grammar/instance-method.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAmB,MAAM,oBAAoB,CAAA;AAS3E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,EAAE,gBAsFnC,CAAA"}

package/dist/domain/addressing/grammar/instance-method.js

@@ -0,0 +1,101 @@
+import { SLUG_PROPERTY } from '#graph/nav/ast/slug';
+import { INBOUND, OUTBOUND } from '#graph/nav/path/step';
+import { INSTANCE_OF, METHOD_OF } from '../edges';
+import { INSTANCE_SEP } from './tokens';
+/**
+ * Instance-dispatch sugar: `::<method>`.
+ *
+ * Emits two steps (the universal "::" tail):
+ *   1. `instance_of` OUTBOUND  — walker at instance, moves to its type.
+ *   2. `method_of`   INBOUND   — walker at the type, moves to the method.
+ *
+ * The `::` token is registered with priority `1` so it beats the
+ * domain `:` token at the lexer (a longer match by length wins after
+ * priority, but explicit priority documents intent).
+ */
+export const instanceMethodGrammar = {
+    name: 'instance-method',
+    tokens: [{ chars: INSTANCE_SEP, kind: 'INSTANCE_SEP', priority: 1 }],
+    parseStep(stream) {
+        const head = stream.peek();
+        if (!head || head.kind !== 'INSTANCE_SEP')
+            return null;
+        // `::` requires a previous step (there must be a source to dispatch on).
+        if (!stream.peekPrevious())
+            return null;
+        const mark = stream.mark();
+        stream.advance();
+        const name = stream.peek();
+        if (!name || name.kind !== 'TEXT') {
+            stream.restore(mark);
+            return null;
+        }
+        stream.advance();
+        return [
+            {
+                kind: 'traversal',
+                edgeClass: INSTANCE_OF,
+                ...OUTBOUND,
+            },
+            {
+                kind: 'traversal',
+                edgeClass: METHOD_OF,
+                ...INBOUND,
+                predicate: {
+                    kind: 'property',
+                    scope: 'edge',
+                    property: SLUG_PROPERTY,
+                    op: '=',
+                    value: name.value,
+                },
+            },
+        ];
+    },
+    serializeStep(step, prev) {
+        // The tail emits two steps but ::method is the joint sugar — only
+        // the method_of step gets a printable form here. The companion
+        // instance_of step serializes to nothing (the `::` is consumed by
+        // the method_of's prefix). Both pieces require the SAME joint
+        // context (instance_of OUT immediately followed by method_of IN)
+        // to fire; without that context, decline so other grammars can
+        // serialize the step in their own form (e.g. `domainGrammar`'s
+        // bare `:method` for a kernel-meta MethodPath whose method_of is
+        // not preceded by an instance dispatch).
+        if (step.kind !== 'traversal')
+            return null;
+        if (step.edgeClass === INSTANCE_OF && step.from === OUTBOUND.from && step.to === OUTBOUND.to) {
+            // `instance_of` step is silent IFF its companion method_of step
+            // is the next-emitted step. The serializer caller threads `prev`
+            // when serializing step N+1, so we can't know N+1 here — but the
+            // companion method_of's own predicate check below will only
+            // emit `::method` when this exact instance_of step is its prev.
+            // So returning `''` unconditionally is safe: an orphan
+            // instance_of (no method_of follows) would still serialize to
+            // empty, but that's malformed input the grammar can't fix
+            // anyway.
+            return '';
+        }
+        if (step.edgeClass !== METHOD_OF)
+            return null;
+        if (step.from !== INBOUND.from || step.to !== INBOUND.to)
+            return null;
+        const p = step.predicate;
+        if (!p || p.kind !== 'property' || p.scope !== 'edge' || p.property !== SLUG_PROPERTY) {
+            return null;
+        }
+        // Joint-context check: only emit `::method` when this method_of is
+        // the second half of the (instance_of OUT, method_of IN) pair.
+        // Without `prev` matching that shape, defer to other grammars
+        // (notably `domainGrammar` which emits `:method` for kernel-meta
+        // MethodPath).
+        if (prev === null ||
+            prev.kind !== 'traversal' ||
+            prev.edgeClass !== INSTANCE_OF ||
+            prev.from !== OUTBOUND.from ||
+            prev.to !== OUTBOUND.to) {
+            return null;
+        }
+        return `${INSTANCE_SEP}${p.value}`;
+    },
+};
+//# sourceMappingURL=instance-method.js.map

package/dist/domain/addressing/grammar/instance-method.js.map

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

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

@@ -0,0 +1,23 @@
+/**
+ * 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 type { GrammarExtension } from '#graph/nav/grammar';
+export declare const KERNEL_META_PATH_GRAMMARS: readonly GrammarExtension[];
+//# sourceMappingURL=set.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../../../../domain/addressing/grammar/set.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAQ1D,eAAO,MAAM,yBAAyB,EAAE,SAAS,gBAAgB,EAKhE,CAAA"}