@astrale-os/kernel-core 0.4.1

package/dist/graph/tree/path/absolute/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../../graph/tree/path/absolute/register.ts"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAI3C"}

package/dist/graph/tree/path/absolute/register.js

@@ -0,0 +1,19 @@
+import { GrammarRegistry } from '#graph/nav/grammar';
+import { PathTypeRegistry } from '#graph/nav/path';
+import { SchemeRegistry } from '#graph/nav/scheme';
+import { absoluteGrammar } from './grammar';
+import { absoluteSegment } from './segment';
+import { absolutePathType } from './type';
+/**
+ * Wire the absolute scheme into the new nav registries.
+ *
+ * Idempotent — registries dedupe identity-equal registrations, so it's
+ * safe to call this from the kernel boot path and from individual
+ * tests that want absolute paths available.
+ */
+export function registerAbsolutePath() {
+    GrammarRegistry.register(absoluteGrammar);
+    SchemeRegistry.register(absoluteSegment);
+    PathTypeRegistry.register(absolutePathType);
+}
+//# sourceMappingURL=register.js.map

package/dist/graph/tree/path/absolute/register.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.js","sourceRoot":"","sources":["../../../../../graph/tree/path/absolute/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAElD,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAA;AAEzC;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB;IAClC,eAAe,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAA;IACzC,cAAc,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAA;IACxC,gBAAgB,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAA;AAC7C,CAAC"}

package/dist/graph/tree/path/absolute/segment.d.ts

@@ -0,0 +1,17 @@
+import type { RecursiveHop } from '#graph/nav/scheme';
+/**
+ * The absolute-tree scheme segment.
+ *
+ * Pure data: a recursive hop on `has_parent` (inbound in IR), with
+ * `ROOT_ANCHOR` emitted at the chain start. Forward and backward
+ * walks are derived generically from this declaration via
+ * `detect` / `identify` in `#graph/nav/scheme`.
+ *
+ * Cardinality contract (enforced schema-side): every node other than
+ * root has exactly one outgoing `has_parent` edge. The walk
+ * terminates at the node whose `path` is `'/'` (the kernel root); a
+ * node that runs out of edges before reaching root raises an
+ * `'orphan'` error.
+ */
+export declare const absoluteSegment: RecursiveHop;
+//# sourceMappingURL=segment.d.ts.map

package/dist/graph/tree/path/absolute/segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../../../graph/tree/path/absolute/segment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAMrD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe,EAAE,YAM7B,CAAA"}

package/dist/graph/tree/path/absolute/segment.js

@@ -0,0 +1,24 @@
+import { ROOT_ANCHOR } from '#graph/nav/path/step';
+import { SEPARATOR_CHAR, TREE_EDGE_TYPE } from './constants';
+/**
+ * The absolute-tree scheme segment.
+ *
+ * Pure data: a recursive hop on `has_parent` (inbound in IR), with
+ * `ROOT_ANCHOR` emitted at the chain start. Forward and backward
+ * walks are derived generically from this declaration via
+ * `detect` / `identify` in `#graph/nav/scheme`.
+ *
+ * Cardinality contract (enforced schema-side): every node other than
+ * root has exactly one outgoing `has_parent` edge. The walk
+ * terminates at the node whose `path` is `'/'` (the kernel root); a
+ * node that runs out of edges before reaching root raises an
+ * `'orphan'` error.
+ */
+export const absoluteSegment = {
+    kind: 'recursive',
+    name: 'absolute',
+    hop: { edge: TREE_EDGE_TYPE, direction: 'inbound' },
+    anchor: ROOT_ANCHOR,
+    terminus: SEPARATOR_CHAR,
+};
+//# sourceMappingURL=segment.js.map

package/dist/graph/tree/path/absolute/segment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment.js","sourceRoot":"","sources":["../../../../../graph/tree/path/absolute/segment.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAElD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAE5D;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,eAAe,GAAiB;IAC3C,IAAI,EAAE,WAAW;IACjB,IAAI,EAAE,UAAU;IAChB,GAAG,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE,SAAS,EAAE,SAAS,EAAE;IACnD,MAAM,EAAE,WAAW;IACnB,QAAQ,EAAE,cAAc;CACzB,CAAA"}

package/dist/graph/tree/path/absolute/type.d.ts

@@ -0,0 +1,52 @@
+import type { PathType } from '#graph/nav/path';
+import type { Step } from '#graph/nav/path/step';
+import type { RelativePath } from '#graph/tree/path/relative';
+import { Path } from '#graph/nav/path';
+/**
+ * Absolute tree address — `/`-prefixed, slug-keyed `has_parent` chain
+ * with a leading {@link RootAnchor}.
+ *
+ * The Step IR is `[RootAnchor, Trav(slug='a'), Trav(slug='b'), ...]`.
+ * The terminal node-of-the-walk is the *last* traversal slug; `slugs`
+ * exposes the chain in tree order (root-first, target-last) — the
+ * order a human reads in the raw string `/a/b/c`.
+ */
+export declare class AbsolutePath extends Path {
+    readonly slugs: readonly string[];
+    constructor(steps: readonly Step[], raw: string);
+    /** @internal Build an absolute from pre-validated slugs. */
+    static _create(slugs: readonly string[], raw?: string): AbsolutePath;
+    /** @internal Narrow a base Path into AbsolutePath without re-parsing. */
+    static _fromPath(path: Path): AbsolutePath;
+    static parse(raw: string): AbsolutePath;
+    static tryParse(raw: string): AbsolutePath | null;
+    static from(...slugs: string[]): AbsolutePath;
+    static root(): AbsolutePath;
+    static basename(p: string): string;
+    static parent(p: string): string | null;
+    static segments(p: string): string[];
+    static looksRelative(p: string): boolean;
+    static looksAbsolute(p: string): boolean;
+    static join(a: string, b: string): string;
+    get isRelative(): false;
+    get isAbsolute(): true;
+    get isRoot(): boolean;
+    get depth(): number;
+    parent(): AbsolutePath;
+    basename(): string | null;
+    append(...slugs: string[]): AbsolutePath;
+    joinRelative(relative: RelativePath): AbsolutePath;
+    startsWith(prefix: AbsolutePath): boolean;
+    equals(other: Path): boolean;
+}
+/**
+ * The PathType for AbsolutePath. Composed of one segment (the absolute
+ * scheme); the segment itself claims the leading RootAnchor plus the
+ * has_parent traversal chain, so default-matches with full Step[]
+ * coverage is correct.
+ *
+ * `class: null` — any node has a tree position, AbsolutePath isn't
+ * tied to a specific class.
+ */
+export declare const absolutePathType: PathType<AbsolutePath>;
+//# sourceMappingURL=type.d.ts.map

package/dist/graph/tree/path/absolute/type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../../../../../graph/tree/path/absolute/type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAE7D,OAAO,EAA2B,IAAI,EAAkB,MAAM,iBAAiB,CAAA;AAM/E;;;;;;;;GAQG;AACH,qBAAa,YAAa,SAAQ,IAAI;IACpC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;IAEjC,YAAY,KAAK,EAAE,SAAS,IAAI,EAAE,EAAE,GAAG,EAAE,MAAM,EAG9C;IAID,4DAA4D;IAC5D,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,YAAY,CAEnE;IAED,yEAAyE;IACzE,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,YAAY,CAEzC;IAID,OAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAQ/C;IAED,OAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAMzD;IAED,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,YAAY,CAS5C;IAED,MAAM,CAAC,IAAI,IAAI,YAAY,CAE1B;IAID,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEjC;IAED,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGtC;IAED,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAEnC;IAED,MAAM,CAAC,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAEvC;IAED,MAAM,CAAC,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAEvC;IAED,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAGxC;IAID,IAAI,UAAU,IAAI,KAAK,CAEtB;IAED,IAAI,UAAU,IAAI,IAAI,CAErB;IAED,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,IAAI,KAAK,IAAI,MAAM,CAElB;IAID,MAAM,IAAI,YAAY,CAGrB;IAED,QAAQ,IAAI,MAAM,GAAG,IAAI,CAGxB;IAED,MAAM,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,YAAY,CAGvC;IAED,YAAY,CAAC,QAAQ,EAAE,YAAY,GAAG,YAAY,CAGjD;IAED,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAMxC;IAEQ,MAAM,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO,CAOpC;CACF;AAID;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,YAAY,CAYnD,CAAA"}

package/dist/graph/tree/path/absolute/type.js

@@ -0,0 +1,197 @@
+import { matchesChain, parsePath, Path, PathParseError } from '#graph/nav/path';
+import { INBOUND, ROOT_ANCHOR } from '#graph/nav/path/step';
+import { SEPARATOR_CHAR, SLUG_PROPERTY, SLUG_RE, TREE_EDGE_TYPE } from './constants';
+import { absoluteSegment } from './segment';
+/**
+ * Absolute tree address — `/`-prefixed, slug-keyed `has_parent` chain
+ * with a leading {@link RootAnchor}.
+ *
+ * The Step IR is `[RootAnchor, Trav(slug='a'), Trav(slug='b'), ...]`.
+ * The terminal node-of-the-walk is the *last* traversal slug; `slugs`
+ * exposes the chain in tree order (root-first, target-last) — the
+ * order a human reads in the raw string `/a/b/c`.
+ */
+export class AbsolutePath extends Path {
+    slugs;
+    constructor(steps, raw) {
+        super(steps, raw);
+        this.slugs = Object.freeze(extractSlugs(steps));
+    }
+    // ─── Internal hooks ──────────────────────────────────────
+    /** @internal Build an absolute from pre-validated slugs. */
+    static _create(slugs, raw) {
+        return new AbsolutePath(buildSteps(slugs), raw ?? serializeFromSlugs(slugs));
+    }
+    /** @internal Narrow a base Path into AbsolutePath without re-parsing. */
+    static _fromPath(path) {
+        return new AbsolutePath(path.steps, path.raw);
+    }
+    // ─── Static factories ────────────────────────────────────
+    static parse(raw) {
+        const p = parsePath(raw);
+        if (!(p instanceof AbsolutePath)) {
+            throw new PathParseError(raw, [
+                { kind: 'not-absolute', message: 'Path is not absolute', position: 0 },
+            ]);
+        }
+        return p;
+    }
+    static tryParse(raw) {
+        try {
+            return AbsolutePath.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    static from(...slugs) {
+        for (const slug of slugs) {
+            if (!SLUG_RE.test(slug)) {
+                throw new PathParseError(slug, [
+                    { kind: 'invalid-slug', message: `Invalid slug: "${slug}"`, position: 0 },
+                ]);
+            }
+        }
+        return AbsolutePath._create(slugs);
+    }
+    static root() {
+        return AbsolutePath._create([], SEPARATOR_CHAR);
+    }
+    // ─── Static string helpers ────────────────────────────────
+    static basename(p) {
+        return p.slice(p.lastIndexOf(SEPARATOR_CHAR) + 1);
+    }
+    static parent(p) {
+        const i = p.lastIndexOf(SEPARATOR_CHAR);
+        return i > 0 ? p.slice(0, i) : null;
+    }
+    static segments(p) {
+        return p.split(SEPARATOR_CHAR).filter(Boolean);
+    }
+    static looksRelative(p) {
+        return p.startsWith('./') || p === '.';
+    }
+    static looksAbsolute(p) {
+        return p.startsWith(SEPARATOR_CHAR);
+    }
+    static join(a, b) {
+        if (a === SEPARATOR_CHAR)
+            return `${SEPARATOR_CHAR}${b}`;
+        return `${a}${SEPARATOR_CHAR}${b}`;
+    }
+    // ─── Getters ──────────────────────────────────────────────
+    get isRelative() {
+        return false;
+    }
+    get isAbsolute() {
+        return true;
+    }
+    get isRoot() {
+        return this.slugs.length === 0;
+    }
+    get depth() {
+        return this.slugs.length;
+    }
+    // ─── Derivation ───────────────────────────────────────────
+    parent() {
+        if (this.slugs.length === 0)
+            return this;
+        return AbsolutePath._create(this.slugs.slice(0, -1));
+    }
+    basename() {
+        if (this.slugs.length === 0)
+            return null;
+        return this.slugs[this.slugs.length - 1];
+    }
+    append(...slugs) {
+        if (slugs.length === 0)
+            return this;
+        return AbsolutePath.from(...this.slugs, ...slugs);
+    }
+    joinRelative(relative) {
+        if (relative.slugs.length === 0)
+            return this;
+        return AbsolutePath._create([...this.slugs, ...relative.slugs]);
+    }
+    startsWith(prefix) {
+        if (prefix.slugs.length > this.slugs.length)
+            return false;
+        for (let i = 0; i < prefix.slugs.length; i++) {
+            if (this.slugs[i] !== prefix.slugs[i])
+                return false;
+        }
+        return true;
+    }
+    equals(other) {
+        if (!(other instanceof AbsolutePath))
+            return false;
+        if (this.slugs.length !== other.slugs.length)
+            return false;
+        for (let i = 0; i < this.slugs.length; i++) {
+            if (this.slugs[i] !== other.slugs[i])
+                return false;
+        }
+        return true;
+    }
+}
+const ABSOLUTE_SEGMENTS = [absoluteSegment];
+/**
+ * The PathType for AbsolutePath. Composed of one segment (the absolute
+ * scheme); the segment itself claims the leading RootAnchor plus the
+ * has_parent traversal chain, so default-matches with full Step[]
+ * coverage is correct.
+ *
+ * `class: null` — any node has a tree position, AbsolutePath isn't
+ * tied to a specific class.
+ */
+export const absolutePathType = {
+    name: 'AbsolutePath',
+    class: null,
+    segments: ABSOLUTE_SEGMENTS,
+    matches(steps) {
+        return matchesChain(ABSOLUTE_SEGMENTS, steps);
+    },
+    build(steps, raw) {
+        return new AbsolutePath(steps, raw || serializeFromSteps(steps));
+    },
+};
+// ── Helpers (private) ─────────────────────────────────────────────
+function extractSlugs(steps) {
+    const out = [];
+    for (const s of steps) {
+        if (s.kind !== 'traversal')
+            continue;
+        const p = s.predicate;
+        if (p?.kind !== 'property')
+            continue;
+        out.push(p.value);
+    }
+    return out;
+}
+function buildSteps(slugs) {
+    const out = [ROOT_ANCHOR];
+    for (const slug of slugs) {
+        out.push({
+            kind: 'traversal',
+            edgeClass: TREE_EDGE_TYPE,
+            ...INBOUND,
+            predicate: {
+                kind: 'property',
+                scope: 'edge',
+                property: SLUG_PROPERTY,
+                op: '=',
+                value: slug,
+            },
+        });
+    }
+    return out;
+}
+function serializeFromSlugs(slugs) {
+    if (slugs.length === 0)
+        return SEPARATOR_CHAR;
+    return SEPARATOR_CHAR + slugs.join(SEPARATOR_CHAR);
+}
+function serializeFromSteps(steps) {
+    return serializeFromSlugs(extractSlugs(steps));
+}
+//# sourceMappingURL=type.js.map

package/dist/graph/tree/path/absolute/type.js.map

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

package/dist/graph/tree/path/absolute-path.d.ts

@@ -0,0 +1,2 @@
+export { AbsolutePath, absolutePathType } from '#graph/tree/path/absolute';
+//# sourceMappingURL=absolute-path.d.ts.map

package/dist/graph/tree/path/absolute-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"absolute-path.d.ts","sourceRoot":"","sources":["../../../../graph/tree/path/absolute-path.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA"}

package/dist/graph/tree/path/absolute-path.js

@@ -0,0 +1,3 @@
+// AbsolutePath is canonical at `#graph/tree/path/absolute` post-collapse.
+export { AbsolutePath, absolutePathType } from '#graph/tree/path/absolute';
+//# sourceMappingURL=absolute-path.js.map

package/dist/graph/tree/path/absolute-path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"absolute-path.js","sourceRoot":"","sources":["../../../../graph/tree/path/absolute-path.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA"}

package/dist/graph/tree/path/constants.d.ts

@@ -0,0 +1,8 @@
+export { SLUG_PROPERTY, SLUG_RE } from '#graph/nav/ast/slug';
+/** Edge type for parent-child tree relationships. */
+export declare const TREE_EDGE_TYPE = "has_parent";
+/** Separator character for tree path segments. */
+export declare const SEPARATOR_CHAR = "/";
+/** Prefix for relative tree paths. */
+export declare const RELATIVE_PREFIX = "./";
+//# sourceMappingURL=constants.d.ts.map

package/dist/graph/tree/path/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../graph/tree/path/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAE5D,qDAAqD;AACrD,eAAO,MAAM,cAAc,eAAe,CAAA;AAE1C,kDAAkD;AAClD,eAAO,MAAM,cAAc,MAAM,CAAA;AAEjC,sCAAsC;AACtC,eAAO,MAAM,eAAe,OAAO,CAAA"}

package/dist/graph/tree/path/constants.js

@@ -0,0 +1,8 @@
+export { SLUG_PROPERTY, SLUG_RE } from '#graph/nav/ast/slug';
+/** Edge type for parent-child tree relationships. */
+export const TREE_EDGE_TYPE = 'has_parent';
+/** Separator character for tree path segments. */
+export const SEPARATOR_CHAR = '/';
+/** Prefix for relative tree paths. */
+export const RELATIVE_PREFIX = './';
+//# sourceMappingURL=constants.js.map

package/dist/graph/tree/path/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../../graph/tree/path/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAE5D,qDAAqD;AACrD,MAAM,CAAC,MAAM,cAAc,GAAG,YAAY,CAAA;AAE1C,kDAAkD;AAClD,MAAM,CAAC,MAAM,cAAc,GAAG,GAAG,CAAA;AAEjC,sCAAsC;AACtC,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,CAAA"}

package/dist/graph/tree/path/index.d.ts

@@ -0,0 +1,6 @@
+export type { TreePath } from './tree-path';
+export { AbsolutePath, absolutePathType } from '#graph/tree/path/absolute';
+export { RelativePath, relativePathType } from '#graph/tree/path/relative';
+export { TREE_EDGE_TYPE, SLUG_PROPERTY, SEPARATOR_CHAR, SLUG_RE, } from '#graph/tree/path/absolute/constants';
+export { RELATIVE_PREFIX } from '#graph/tree/path/relative';
+//# sourceMappingURL=index.d.ts.map

package/dist/graph/tree/path/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../graph/tree/path/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AAC1E,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AAC1E,OAAO,EACL,cAAc,EACd,aAAa,EACb,cAAc,EACd,OAAO,GACR,MAAM,qCAAqC,CAAA;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA"}

package/dist/graph/tree/path/index.js

@@ -0,0 +1,5 @@
+export { AbsolutePath, absolutePathType } from '#graph/tree/path/absolute';
+export { RelativePath, relativePathType } from '#graph/tree/path/relative';
+export { TREE_EDGE_TYPE, SLUG_PROPERTY, SEPARATOR_CHAR, SLUG_RE, } from '#graph/tree/path/absolute/constants';
+export { RELATIVE_PREFIX } from '#graph/tree/path/relative';
+//# sourceMappingURL=index.js.map

package/dist/graph/tree/path/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../graph/tree/path/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AAC1E,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AAC1E,OAAO,EACL,cAAc,EACd,aAAa,EACb,cAAc,EACd,OAAO,GACR,MAAM,qCAAqC,CAAA;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA"}

package/dist/graph/tree/path/relative/constants.d.ts

@@ -0,0 +1,5 @@
+/** Prefix for relative tree paths. */
+export declare const RELATIVE_PREFIX = "./";
+/** Bare-self relative path. */
+export declare const SELF_TOKEN = ".";
+//# sourceMappingURL=constants.d.ts.map

package/dist/graph/tree/path/relative/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../graph/tree/path/relative/constants.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,eAAO,MAAM,eAAe,OAAO,CAAA;AAEnC,+BAA+B;AAC/B,eAAO,MAAM,UAAU,MAAM,CAAA"}

package/dist/graph/tree/path/relative/constants.js

@@ -0,0 +1,5 @@
+/** Prefix for relative tree paths. */
+export const RELATIVE_PREFIX = './';
+/** Bare-self relative path. */
+export const SELF_TOKEN = '.';
+//# sourceMappingURL=constants.js.map

package/dist/graph/tree/path/relative/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../../../graph/tree/path/relative/constants.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,CAAA;AAEnC,+BAA+B;AAC/B,MAAM,CAAC,MAAM,UAAU,GAAG,GAAG,CAAA"}

package/dist/graph/tree/path/relative/grammar.d.ts

@@ -0,0 +1,19 @@
+import type { GrammarExtension } from '#graph/nav/grammar';
+/**
+ * Relative-tree sugar: `./` prefix turns the same `/`-separated chain
+ * the absolute grammar emits into a relative path.
+ *
+ * The relative grammar contributes only a *prefix* hook. The chain
+ * itself reuses the absolute grammar's `/` separator — every `./foo/bar`
+ * tokenizes as `DOT_SLASH SLASH foo SLASH bar` (after the prefix is
+ * consumed) and the absolute grammar produces the has_parent traversals
+ * verbatim. The relativity flag is the only discriminator and lives on
+ * the parse result, never as a sentinel step.
+ *
+ * Bare `.` (root self) is a token in its own right — TEXT `.` would
+ * conflict with the slug regex, so the lexer emits a dedicated DOT
+ * token-kind only when followed by `/`. For lone `.` (one-char input)
+ * the prefix hook detects the token, consumes it, and emits no chain.
+ */
+export declare const relativeGrammar: GrammarExtension;
+//# sourceMappingURL=grammar.d.ts.map

package/dist/graph/tree/path/relative/grammar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammar.d.ts","sourceRoot":"","sources":["../../../../../graph/tree/path/relative/grammar.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAiC,MAAM,oBAAoB,CAAA;AAKzF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,eAAe,EAAE,gBAkC7B,CAAA"}

package/dist/graph/tree/path/relative/grammar.js

@@ -0,0 +1,47 @@
+import { RELATIVE_PREFIX, SELF_TOKEN } from './constants';
+/**
+ * Relative-tree sugar: `./` prefix turns the same `/`-separated chain
+ * the absolute grammar emits into a relative path.
+ *
+ * The relative grammar contributes only a *prefix* hook. The chain
+ * itself reuses the absolute grammar's `/` separator — every `./foo/bar`
+ * tokenizes as `DOT_SLASH SLASH foo SLASH bar` (after the prefix is
+ * consumed) and the absolute grammar produces the has_parent traversals
+ * verbatim. The relativity flag is the only discriminator and lives on
+ * the parse result, never as a sentinel step.
+ *
+ * Bare `.` (root self) is a token in its own right — TEXT `.` would
+ * conflict with the slug regex, so the lexer emits a dedicated DOT
+ * token-kind only when followed by `/`. For lone `.` (one-char input)
+ * the prefix hook detects the token, consumes it, and emits no chain.
+ */
+export const relativeGrammar = {
+    name: 'relative',
+    tokens: [{ chars: RELATIVE_PREFIX, kind: 'DOT_SLASH', priority: 1 }],
+    parsePrefix(stream) {
+        const head = stream.peek();
+        if (!head)
+            return null;
+        if (head.kind === 'DOT_SLASH') {
+            stream.advance();
+            return { isRelative: true };
+        }
+        if (head.kind === 'TEXT' && head.value === SELF_TOKEN) {
+            stream.advance();
+            return { isRelative: true };
+        }
+        return null;
+    },
+    parseStep(_stream) {
+        return null;
+    },
+    serializeStep(_step) {
+        return null;
+    },
+    serializePrefix(isRelative) {
+        if (!isRelative)
+            return null;
+        return SELF_TOKEN;
+    },
+};
+//# sourceMappingURL=grammar.js.map

package/dist/graph/tree/path/relative/grammar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammar.js","sourceRoot":"","sources":["../../../../../graph/tree/path/relative/grammar.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAEzD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,eAAe,GAAqB;IAC/C,IAAI,EAAE,UAAU;IAEhB,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,eAAe,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC,EAAE,CAA6B;IAEhG,WAAW,CAAC,MAAmB;QAC7B,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,EAAE,CAAA;QAC1B,IAAI,CAAC,IAAI;YAAE,OAAO,IAAI,CAAA;QAEtB,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;YAC9B,MAAM,CAAC,OAAO,EAAE,CAAA;YAChB,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,CAAA;QAC7B,CAAC;QAED,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,IAAI,IAAI,CAAC,KAAK,KAAK,UAAU,EAAE,CAAC;YACtD,MAAM,CAAC,OAAO,EAAE,CAAA;YAChB,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,CAAA;QAC7B,CAAC;QAED,OAAO,IAAI,CAAA;IACb,CAAC;IAED,SAAS,CAAC,OAAoB;QAC5B,OAAO,IAAI,CAAA;IACb,CAAC;IAED,aAAa,CAAC,KAAW;QACvB,OAAO,IAAI,CAAA;IACb,CAAC;IAED,eAAe,CAAC,UAAmB;QACjC,IAAI,CAAC,UAAU;YAAE,OAAO,IAAI,CAAA;QAC5B,OAAO,UAAU,CAAA;IACnB,CAAC;CACF,CAAA"}

package/dist/graph/tree/path/relative/index.d.ts

@@ -0,0 +1,5 @@
+export { RelativePath, relativePathType } from './type';
+export { relativeGrammar } from './grammar';
+export { registerRelativePath } from './register';
+export { RELATIVE_PREFIX, SELF_TOKEN } from './constants';
+//# sourceMappingURL=index.d.ts.map

package/dist/graph/tree/path/relative/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../graph/tree/path/relative/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAA;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAC3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AACjD,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA"}

package/dist/graph/tree/path/relative/index.js

@@ -0,0 +1,5 @@
+export { RelativePath, relativePathType } from './type';
+export { relativeGrammar } from './grammar';
+export { registerRelativePath } from './register';
+export { RELATIVE_PREFIX, SELF_TOKEN } from './constants';
+//# sourceMappingURL=index.js.map

package/dist/graph/tree/path/relative/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../graph/tree/path/relative/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAA;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAC3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AACjD,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA"}

package/dist/graph/tree/path/relative/register.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Wire the relative-tree scheme into the new nav registries.
+ *
+ * Idempotent — registries dedupe identity-equal registrations, so it's
+ * safe to call this from the kernel boot path and from individual
+ * tests that want relative paths available. Note: depends on the
+ * absolute scheme also being registered (the relative path reuses the
+ * absolute segment and its `/` separator token).
+ */
+export declare function registerRelativePath(): void;
+//# sourceMappingURL=register.d.ts.map

package/dist/graph/tree/path/relative/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../../graph/tree/path/relative/register.ts"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAG3C"}

package/dist/graph/tree/path/relative/register.js

@@ -0,0 +1,18 @@
+import { GrammarRegistry } from '#graph/nav/grammar';
+import { PathTypeRegistry } from '#graph/nav/path';
+import { relativeGrammar } from './grammar';
+import { relativePathType } from './type';
+/**
+ * Wire the relative-tree scheme into the new nav registries.
+ *
+ * Idempotent — registries dedupe identity-equal registrations, so it's
+ * safe to call this from the kernel boot path and from individual
+ * tests that want relative paths available. Note: depends on the
+ * absolute scheme also being registered (the relative path reuses the
+ * absolute segment and its `/` separator token).
+ */
+export function registerRelativePath() {
+    GrammarRegistry.register(relativeGrammar);
+    PathTypeRegistry.register(relativePathType);
+}
+//# sourceMappingURL=register.js.map

package/dist/graph/tree/path/relative/register.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.js","sourceRoot":"","sources":["../../../../../graph/tree/path/relative/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAElD,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAA;AAEzC;;;;;;;;GAQG;AACH,MAAM,UAAU,oBAAoB;IAClC,eAAe,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAA;IACzC,gBAAgB,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAA;AAC7C,CAAC"}

package/dist/graph/tree/path/relative/type.d.ts

@@ -0,0 +1,42 @@
+import type { PathType } from '#graph/nav/path';
+import type { Step } from '#graph/nav/path/step';
+import { Path } from '#graph/nav/path';
+import { AbsolutePath } from '#graph/tree/path/absolute';
+/**
+ * Relative tree address — `./`-prefixed slug chain. Discriminator is
+ * structural: a relative path's Step[] has *no* leading anchor (no
+ * RootAnchor), only `has_parent` inbound traversals. Absolute paths
+ * with the same slug chain carry a RootAnchor at `steps[0]`.
+ *
+ * Like AbsolutePath, the steps walk source(child) → target(parent), so
+ * `slugs` reads in human order — `./a/b` exposes `['a', 'b']`.
+ */
+export declare class RelativePath extends Path {
+    readonly slugs: readonly string[];
+    constructor(steps: readonly Step[], raw: string);
+    /** @internal Build a relative from pre-validated slugs. */
+    static _create(slugs: readonly string[], raw?: string): RelativePath;
+    /** @internal Narrow a base Path into RelativePath without re-parsing. */
+    static _fromPath(path: Path): RelativePath;
+    static parse(raw: string): RelativePath;
+    static tryParse(raw: string): RelativePath | null;
+    static from(...slugs: string[]): RelativePath;
+    get isRelative(): true;
+    get isAbsolute(): false;
+    get isSelf(): boolean;
+    get depth(): number;
+    parent(): RelativePath | null;
+    basename(): string | null;
+    append(...slugs: string[]): RelativePath;
+    join(other: RelativePath): RelativePath;
+    toAbsolute(base: AbsolutePath): AbsolutePath;
+    equals(other: Path): boolean;
+}
+/**
+ * The PathType for RelativePath. Custom `matches` checks: no leading
+ * anchor + only has_parent inbound traversals. No segments to register
+ * in the registry (relative paths bypass the segment-based identify
+ * pipeline since you can't recover them from a node alone).
+ */
+export declare const relativePathType: PathType<RelativePath>;
+//# sourceMappingURL=type.d.ts.map

package/dist/graph/tree/path/relative/type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../../../../../graph/tree/path/relative/type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;AAEhD,OAAO,EAAa,IAAI,EAAkB,MAAM,iBAAiB,CAAA;AAEjE,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAUxD;;;;;;;;GAQG;AACH,qBAAa,YAAa,SAAQ,IAAI;IACpC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;IAEjC,YAAY,KAAK,EAAE,SAAS,IAAI,EAAE,EAAE,GAAG,EAAE,MAAM,EAG9C;IAID,2DAA2D;IAC3D,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,YAAY,CAEnE;IAED,yEAAyE;IACzE,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,YAAY,CAEzC;IAID,OAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAQ/C;IAED,OAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAMzD;IAED,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,YAAY,CAS5C;IAID,IAAI,UAAU,IAAI,IAAI,CAErB;IAED,IAAI,UAAU,IAAI,KAAK,CAEtB;IAED,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,IAAI,KAAK,IAAI,MAAM,CAElB;IAID,MAAM,IAAI,YAAY,GAAG,IAAI,CAG5B;IAED,QAAQ,IAAI,MAAM,GAAG,IAAI,CAGxB;IAED,MAAM,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,YAAY,CAUvC;IAED,IAAI,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY,CAGtC;IAED,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,CAE3C;IAEQ,MAAM,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO,CAOpC;CACF;AAED;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,YAAY,CA0BnD,CAAA"}