@astrale-os/kernel-core 0.4.1

package/dist/graph/nav/path/errors.js

@@ -0,0 +1,61 @@
+/**
+ * Raised when a string cannot be parsed into a valid path. Carries the
+ * original input alongside one or more lex/parse-level diagnostics.
+ */
+export class PathParseError extends Error {
+    name = 'PathParseError';
+    input;
+    errors;
+    constructor(input, errors) {
+        super(`Failed to parse path "${input}": ${errors.map((e) => e.message).join('; ')}`);
+        this.input = input;
+        this.errors = errors;
+    }
+    /** Alias for `input` — older callsites read `error.raw`. */
+    get raw() {
+        return this.input;
+    }
+}
+/**
+ * Raised when a node cannot be identified into a typed path — the
+ * walk-back terminated early or hit a graph state that violates the
+ * scheme's anchoring-edge invariant.
+ */
+export class IdentifyError extends Error {
+    name = 'IdentifyError';
+    reason;
+    constructor(message, reason = 'walk-back failed') {
+        super(message);
+        this.reason = reason;
+    }
+}
+export class PathNotFoundError extends Error {
+    path;
+    failedAtStep;
+    context;
+    name = 'PathNotFoundError';
+    constructor(path, failedAtStep, context) {
+        const hint = failedAtStep.length > 24 || /\s/.test(failedAtStep) ? ` — ${failedAtStep}` : '';
+        super(`Path not found: "${path.raw}"${context ? ` (from context ${context})` : ''}${hint}`);
+        this.path = path;
+        this.failedAtStep = failedAtStep;
+        this.context = context;
+    }
+}
+export class AmbiguousPathError extends Error {
+    path;
+    name = 'AmbiguousPathError';
+    constructor(path) {
+        super(`Path is ambiguous: "${path.raw}"`);
+        this.path = path;
+    }
+}
+export class MissingContextError extends Error {
+    reason;
+    name = 'MissingContextError';
+    constructor(reason) {
+        super(`Missing path context: ${reason}`);
+        this.reason = reason;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/graph/nav/path/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../../graph/nav/path/errors.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,MAAM,OAAO,cAAe,SAAQ,KAAK;IACrB,IAAI,GAAG,gBAAgB,CAAA;IAChC,KAAK,CAAQ;IACb,MAAM,CAA4B;IAE3C,YAAY,KAAa,EAAE,MAAkC;QAC3D,KAAK,CAAC,yBAAyB,KAAK,MAAM,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;QACpF,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QAClB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;IACtB,CAAC;IAED,4DAA4D;IAC5D,IAAI,GAAG;QACL,OAAO,IAAI,CAAC,KAAK,CAAA;IACnB,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,OAAO,aAAc,SAAQ,KAAK;IACpB,IAAI,GAAG,eAAe,CAAA;IAC/B,MAAM,CAAQ;IAEvB,YAAY,OAAe,EAAE,MAAM,GAAG,kBAAkB;QACtD,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;IACtB,CAAC;CACF;AAED,MAAM,OAAO,iBAAkB,SAAQ,KAAK;IAGxB,IAAI;IACJ,YAAY;IACZ,OAAO;IAJP,IAAI,GAAG,mBAAmB,CAAA;IAC5C,YACkB,IAAqB,EACrB,YAAoB,EACpB,OAAgB;QAEhC,MAAM,IAAI,GAAG,YAAY,CAAC,MAAM,GAAG,EAAE,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,MAAM,YAAY,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;QAC5F,KAAK,CAAC,oBAAoB,IAAI,CAAC,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC,kBAAkB,OAAO,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,CAAA;oBAL3E,IAAI;4BACJ,YAAY;uBACZ,OAAO;IAIzB,CAAC;CACF;AAED,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IAEf,IAAI;IADd,IAAI,GAAG,oBAAoB,CAAA;IAC7C,YAA4B,IAAqB;QAC/C,KAAK,CAAC,uBAAuB,IAAI,CAAC,GAAG,GAAG,CAAC,CAAA;oBADf,IAAI;IAEhC,CAAC;CACF;AAED,MAAM,OAAO,mBAAoB,SAAQ,KAAK;IAEhB,MAAM;IADhB,IAAI,GAAG,qBAAqB,CAAA;IAC9C,YAA4B,MAAc;QACxC,KAAK,CAAC,yBAAyB,MAAM,EAAE,CAAC,CAAA;sBADd,MAAM;IAElC,CAAC;CACF"}

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

@@ -0,0 +1,19 @@
+export { Path, toPath } from './path';
+export { parsePath, safeParsePath, type ParsePathResult } from './parse';
+export type { Step, Anchor, Traversal } from '../ast/step';
+export { OUTBOUND, INBOUND, ROOT_ANCHOR, idAnchor, isRootAnchor } from '../ast/step';
+export { reverseStep, reverseSteps, stepsEqual } from '../ast/step/reverse';
+export type { Predicate, PropertyPredicate, AndPredicate, OrPredicate, NotPredicate, PredicateOp, PredicateScope, } from '../ast/predicate/types';
+export { IdPath, idPathType, registerIdPath } from './kinds/id-path';
+export type { PathType } from './kinds/path-type';
+export { PathTypeRegistry } from './kinds/registry';
+export { walkChain, matchesChain, chainSpan } from './kinds/chain';
+export { buildPath } from './build';
+export { serializeStep, serializeSteps, serializeStepCore } from '../serialize/steps';
+export { traversalFromHop, reconstructSteps } from '../scheme/slug';
+export { PathParseError, IdentifyError, PathNotFoundError, AmbiguousPathError, MissingContextError, } from './errors';
+export type { Slug } from '../ast/slug';
+export { slugSchema, SLUG_PROPERTY } from '../ast/slug';
+export { pathSchema, idPathSchema, pathLike, PathValidationError } from './zod';
+export type { PathCtor, PathValidationErrorKind, PathValidationIssue } from './zod';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../graph/nav/path/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACrC,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,SAAS,CAAA;AAGxE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC1D,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AACpF,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAG3E,YAAY,EACV,SAAS,EACT,iBAAiB,EACjB,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,WAAW,EACX,cAAc,GACf,MAAM,wBAAwB,CAAA;AAG/B,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAGpE,YAAY,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAClE,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAGrF,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAGnE,OAAO,EACL,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,UAAU,CAAA;AAGjB,YAAY,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAGvD,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,OAAO,CAAA;AAC/E,YAAY,EAAE,QAAQ,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,MAAM,OAAO,CAAA"}

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

@@ -0,0 +1,19 @@
+// ─── Path (base class) + parsing entry points ──────────────
+export { Path, toPath } from './path';
+export { parsePath, safeParsePath } from './parse';
+export { OUTBOUND, INBOUND, ROOT_ANCHOR, idAnchor, isRootAnchor } from '../ast/step';
+export { reverseStep, reverseSteps, stepsEqual } from '../ast/step/reverse';
+// ─── Id path ───────────────────────────────────────────────
+export { IdPath, idPathType, registerIdPath } from './kinds/id-path';
+export { PathTypeRegistry } from './kinds/registry';
+export { walkChain, matchesChain, chainSpan } from './kinds/chain';
+export { buildPath } from './build';
+export { serializeStep, serializeSteps, serializeStepCore } from '../serialize/steps';
+// ─── Slug-array convergence (shared with cypher backend) ──
+export { traversalFromHop, reconstructSteps } from '../scheme/slug';
+// ─── Errors ────────────────────────────────────────────────
+export { PathParseError, IdentifyError, PathNotFoundError, AmbiguousPathError, MissingContextError, } from './errors';
+export { slugSchema, SLUG_PROPERTY } from '../ast/slug';
+// ─── Zod factories ─────────────────────────────────────────
+export { pathSchema, idPathSchema, pathLike, PathValidationError } from './zod';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../graph/nav/path/index.ts"],"names":[],"mappings":"AAAA,8DAA8D;AAC9D,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACrC,OAAO,EAAE,SAAS,EAAE,aAAa,EAAwB,MAAM,SAAS,CAAA;AAIxE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AACpF,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAa3E,8DAA8D;AAC9D,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAIpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAClE,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAErF,6DAA6D;AAC7D,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAEnE,8DAA8D;AAC9D,OAAO,EACL,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,UAAU,CAAA;AAIjB,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEvD,8DAA8D;AAC9D,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,OAAO,CAAA"}

package/dist/graph/nav/path/kinds/chain.d.ts

@@ -0,0 +1,38 @@
+import type { GraphView } from '#graph';
+import type { Node } from '#graph/node/node';
+import type { Step } from '../../ast/step';
+import type { SchemeSegment } from '../../scheme/segment';
+import type { PathType } from './path-type';
+/**
+ * Match Step[] against a segment chain: each segment claims a
+ * contiguous run, segments are tried left-to-right, and the steps must
+ * be fully exhausted. Takes raw segments so PathType factories can
+ * call it without a PathType instance in scope.
+ */
+export declare function matchesChain(segments: readonly SchemeSegment[], steps: readonly Step[]): boolean;
+/**
+ * Total steps a segment chain collectively consumes against a Step[].
+ * Used by {@link PathTypeRegistry.detect} as the specificity
+ * tiebreaker — types whose segments cover more steps are preferred.
+ */
+export declare function chainSpan(segments: readonly SchemeSegment[], steps: readonly Step[]): number;
+/**
+ * Walk a node back through a PathType's segment chain (target → anchor)
+ * and lift the harvested slugs into the IR `Step[]` the forward
+ * direction would have parsed.
+ *
+ * Two stages:
+ *   1. {@link walkSlugs} — physical walk via the {@link GraphView},
+ *      producing the same flat slug array the cypher backend's CASE
+ *      expression projects (single-hop slugs leaf-to-anchor, then
+ *      recursive-hop slugs leaf-to-root).
+ *   2. {@link reconstructSteps} — shared with the cypher backend, lifts
+ *      the slug array back into `Step[]` using the PathType's segment
+ *      chain.
+ *
+ * The structural symmetry with the cypher backend lives at the slug
+ * array boundary: both backends harvest one in their own execution
+ * model and converge on `reconstructSteps`.
+ */
+export declare function walkChain(type: PathType, target: Node, graph: GraphView): readonly Step[];
+//# sourceMappingURL=chain.d.ts.map

package/dist/graph/nav/path/kinds/chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain.d.ts","sourceRoot":"","sources":["../../../../../graph/nav/path/kinds/chain.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAE5C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAO3C;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,EAAE,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,OAAO,CAQhG;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,EAAE,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,MAAM,CAQ5F;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,GAAG,SAAS,IAAI,EAAE,CAEzF"}

package/dist/graph/nav/path/kinds/chain.js

@@ -0,0 +1,84 @@
+import { reconstructSteps } from '../../scheme/slug';
+import { span } from '../../scheme/span';
+import { walk } from '../../scheme/walk';
+import { IdentifyError } from '../errors';
+/**
+ * Match Step[] against a segment chain: each segment claims a
+ * contiguous run, segments are tried left-to-right, and the steps must
+ * be fully exhausted. Takes raw segments so PathType factories can
+ * call it without a PathType instance in scope.
+ */
+export function matchesChain(segments, steps) {
+    let offset = 0;
+    for (const seg of segments) {
+        const n = span(seg, steps, offset);
+        if (n === 0)
+            return false;
+        offset += n;
+    }
+    return offset === steps.length;
+}
+/**
+ * Total steps a segment chain collectively consumes against a Step[].
+ * Used by {@link PathTypeRegistry.detect} as the specificity
+ * tiebreaker — types whose segments cover more steps are preferred.
+ */
+export function chainSpan(segments, steps) {
+    let offset = 0;
+    for (const seg of segments) {
+        const n = span(seg, steps, offset);
+        if (n === 0)
+            return 0;
+        offset += n;
+    }
+    return offset;
+}
+/**
+ * Walk a node back through a PathType's segment chain (target → anchor)
+ * and lift the harvested slugs into the IR `Step[]` the forward
+ * direction would have parsed.
+ *
+ * Two stages:
+ *   1. {@link walkSlugs} — physical walk via the {@link GraphView},
+ *      producing the same flat slug array the cypher backend's CASE
+ *      expression projects (single-hop slugs leaf-to-anchor, then
+ *      recursive-hop slugs leaf-to-root).
+ *   2. {@link reconstructSteps} — shared with the cypher backend, lifts
+ *      the slug array back into `Step[]` using the PathType's segment
+ *      chain.
+ *
+ * The structural symmetry with the cypher backend lives at the slug
+ * array boundary: both backends harvest one in their own execution
+ * model and converge on `reconstructSteps`.
+ */
+export function walkChain(type, target, graph) {
+    return reconstructSteps(type, walkSlugs(type, target, graph));
+}
+/**
+ * Harvest the flat slug array a PathType's segment chain would produce
+ * for `target`. Order matches the cypher walker's CASE emission so
+ * `reconstructSteps` is the single decoding site for both backends.
+ *
+ * Throws {@link IdentifyError} when a segment's predecessor goes null
+ * before the outermost segment runs — that would mean the scheme's
+ * anchoring-edge invariant was violated mid-walk.
+ */
+function walkSlugs(type, target, graph) {
+    const linear = [];
+    const tree = [];
+    let cursor = target;
+    for (let i = type.segments.length - 1; i >= 0; i--) {
+        if (cursor === null) {
+            throw new IdentifyError(`Walk-back terminated early in ${type.name}: segment ${i} (${type.segments[i].name}) has no source node`);
+        }
+        const seg = type.segments[i];
+        const r = walk(seg, cursor, graph);
+        if (seg.kind === 'single')
+            linear.push(...r.slugs);
+        else
+            tree.push(...r.slugs);
+        cursor = r.predecessor;
+    }
+    return [...linear, ...tree];
+}
+//# sourceMappingURL=chain.js.map

package/dist/graph/nav/path/kinds/chain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain.js","sourceRoot":"","sources":["../../../../../graph/nav/path/kinds/chain.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEzC;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,QAAkC,EAAE,KAAsB;IACrF,IAAI,MAAM,GAAG,CAAC,CAAA;IACd,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;QAC3B,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE,KAAK,EAAE,MAAM,CAAC,CAAA;QAClC,IAAI,CAAC,KAAK,CAAC;YAAE,OAAO,KAAK,CAAA;QACzB,MAAM,IAAI,CAAC,CAAA;IACb,CAAC;IACD,OAAO,MAAM,KAAK,KAAK,CAAC,MAAM,CAAA;AAChC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,SAAS,CAAC,QAAkC,EAAE,KAAsB;IAClF,IAAI,MAAM,GAAG,CAAC,CAAA;IACd,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;QAC3B,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE,KAAK,EAAE,MAAM,CAAC,CAAA;QAClC,IAAI,CAAC,KAAK,CAAC;YAAE,OAAO,CAAC,CAAA;QACrB,MAAM,IAAI,CAAC,CAAA;IACb,CAAC;IACD,OAAO,MAAM,CAAA;AACf,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,SAAS,CAAC,IAAc,EAAE,MAAY,EAAE,KAAgB;IACtE,OAAO,gBAAgB,CAAC,IAAI,EAAE,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAA;AAC/D,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,SAAS,CAAC,IAAc,EAAE,MAAY,EAAE,KAAgB;IAC/D,MAAM,MAAM,GAAa,EAAE,CAAA;IAC3B,MAAM,IAAI,GAAa,EAAE,CAAA;IACzB,IAAI,MAAM,GAAuB,MAAM,CAAA;IACvC,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QACnD,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;YACpB,MAAM,IAAI,aAAa,CACrB,iCAAiC,IAAI,CAAC,IAAI,aAAa,CAAC,KAAK,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAE,CAAC,IAAI,sBAAsB,CAC1G,CAAA;QACH,CAAC;QACD,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAE,CAAA;QAC7B,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,CAAA;QAClC,IAAI,GAAG,CAAC,IAAI,KAAK,QAAQ;YAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAA;;YAC7C,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAA;QAC1B,MAAM,GAAG,CAAC,CAAC,WAAW,CAAA;IACxB,CAAC;IACD,OAAO,CAAC,GAAG,MAAM,EAAE,GAAG,IAAI,CAAC,CAAA;AAC7B,CAAC"}

package/dist/graph/nav/path/kinds/id-path.d.ts

@@ -0,0 +1,44 @@
+import type { NodeId } from '#ids';
+import type { Step } from '../../ast/step';
+import type { PathType } from './path-type';
+import { Path } from '../path';
+/**
+ * Direct node reference by id — `@<nodeId>`.
+ *
+ * The simplest typed path: zero traversal, one anchor. Always
+ * absolute. The `@` token is core grammar — no GrammarExtension is
+ * needed; the parser handles it directly.
+ */
+export declare class IdPath extends Path {
+    readonly id: NodeId;
+    constructor(steps: readonly Step[], raw: string, id: NodeId);
+    /** @internal Narrow a base Path into IdPath without re-parsing. */
+    static _fromPath(path: Path): IdPath;
+    static parse(raw: string): IdPath;
+    static tryParse(raw: string): IdPath | null;
+    static from(id: NodeId): IdPath;
+    get isRelative(): false;
+    equals(other: Path): boolean;
+}
+/**
+ * The PathType for IdPath. Zero segments — the anchor is not an
+ * anchoring edge, it's a direct node pointer. `matches` checks the
+ * step shape directly. `build` extracts the id from the anchor step.
+ *
+ * Excludes the implicit-root anchor (`__SYSTEM__`) — a path with a
+ * single root anchor is the empty AbsolutePath (`/`), not an IdPath.
+ *
+ * Lowest specificity in the registry: only matches when no other type
+ * does. Enforced by the registry's "longest segment chain wins" rule
+ * (zero segments = lowest specificity).
+ */
+export declare const idPathType: PathType<IdPath>;
+/**
+ * Wire IdPath into the PathTypeRegistry.
+ *
+ * No GrammarExtension or SchemeSegment to register — `@` is core
+ * grammar, IdPath has no anchoring edge. The PathType is the only
+ * artifact that needs to opt into the registry.
+ */
+export declare function registerIdPath(): void;
+//# sourceMappingURL=id-path.d.ts.map

package/dist/graph/nav/path/kinds/id-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"id-path.d.ts","sourceRoot":"","sources":["../../../../../graph/nav/path/kinds/id-path.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAElC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAK3C,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAG9B;;;;;;GAMG;AACH,qBAAa,MAAO,SAAQ,IAAI;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IAEnB,YAAY,KAAK,EAAE,SAAS,IAAI,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAG1D;IAID,mEAAmE;IACnE,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAQnC;IAID,OAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQzC;IAED,OAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAMnD;IAED,MAAM,CAAC,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAE9B;IAED,IAAI,UAAU,IAAI,KAAK,CAEtB;IAEQ,MAAM,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO,CAGpC;CACF;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,MAAM,CAqBvC,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAErC"}

package/dist/graph/nav/path/kinds/id-path.js

@@ -0,0 +1,104 @@
+import { idAnchor, isRootAnchor } from '../../ast/step';
+import { PathParseError } from '../errors';
+import { parsePath } from '../parse';
+import { Path } from '../path';
+import { PathTypeRegistry } from './registry';
+/**
+ * Direct node reference by id — `@<nodeId>`.
+ *
+ * The simplest typed path: zero traversal, one anchor. Always
+ * absolute. The `@` token is core grammar — no GrammarExtension is
+ * needed; the parser handles it directly.
+ */
+export class IdPath extends Path {
+    id;
+    constructor(steps, raw, id) {
+        super(steps, raw);
+        this.id = id;
+    }
+    // ─── Internal hooks ──────────────────────────────────────
+    /** @internal Narrow a base Path into IdPath without re-parsing. */
+    static _fromPath(path) {
+        const step = path.steps[0];
+        if (path.steps.length !== 1 || !step || step.kind !== 'anchor') {
+            throw new PathParseError(path.raw, [
+                { kind: 'not-id', message: 'IdPath requires a single anchor step', position: 0 },
+            ]);
+        }
+        return new IdPath(path.steps, path.raw, step.id);
+    }
+    // ─── Static factories ────────────────────────────────────
+    static parse(raw) {
+        const p = parsePath(raw);
+        if (!(p instanceof IdPath)) {
+            throw new PathParseError(raw, [
+                { kind: 'not-id', message: 'Path is not an id reference', position: 0 },
+            ]);
+        }
+        return p;
+    }
+    static tryParse(raw) {
+        try {
+            return IdPath.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    static from(id) {
+        return new IdPath([idAnchor(id)], `@${id}`, id);
+    }
+    get isRelative() {
+        return false;
+    }
+    equals(other) {
+        if (!(other instanceof IdPath))
+            return false;
+        return this.id === other.id;
+    }
+}
+/**
+ * The PathType for IdPath. Zero segments — the anchor is not an
+ * anchoring edge, it's a direct node pointer. `matches` checks the
+ * step shape directly. `build` extracts the id from the anchor step.
+ *
+ * Excludes the implicit-root anchor (`__SYSTEM__`) — a path with a
+ * single root anchor is the empty AbsolutePath (`/`), not an IdPath.
+ *
+ * Lowest specificity in the registry: only matches when no other type
+ * does. Enforced by the registry's "longest segment chain wins" rule
+ * (zero segments = lowest specificity).
+ */
+export const idPathType = {
+    name: 'IdPath',
+    class: null,
+    segments: [],
+    matches(steps) {
+        if (steps.length !== 1)
+            return false;
+        const head = steps[0];
+        if (!head || head.kind !== 'anchor')
+            return false;
+        return !isRootAnchor(head);
+    },
+    build(steps, raw) {
+        const step = steps[0];
+        if (steps.length !== 1 || !step || step.kind !== 'anchor') {
+            throw new PathParseError(raw, [
+                { kind: 'not-id', message: 'IdPath requires a single anchor step', position: 0 },
+            ]);
+        }
+        return new IdPath(steps, raw || `@${step.id}`, step.id);
+    },
+};
+/**
+ * Wire IdPath into the PathTypeRegistry.
+ *
+ * No GrammarExtension or SchemeSegment to register — `@` is core
+ * grammar, IdPath has no anchoring edge. The PathType is the only
+ * artifact that needs to opt into the registry.
+ */
+export function registerIdPath() {
+    PathTypeRegistry.register(idPathType);
+}
+//# sourceMappingURL=id-path.js.map

package/dist/graph/nav/path/kinds/id-path.js.map

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

package/dist/graph/nav/path/kinds/path-type.d.ts

@@ -0,0 +1,51 @@
+import type { Step } from '../../ast/step';
+import type { SchemeSegment } from '../../scheme/segment';
+import type { Path } from '../path';
+/**
+ * A typed wrapper over a Step[] produced by a fixed sequence of
+ * scheme segments.
+ *
+ * `segments` is ordered outer-anchor first. Forward matching: each
+ * segment's `detect` consumes its run left-to-right; backward
+ * identifying: each segment's `identify` runs right-to-left, threading
+ * the predecessor cursor.
+ *
+ * A PathType is the only place that knows how to wrap a validated
+ * Step[] into a typed instance — schemes are graph-side, grammar
+ * extensions are sugar-side, neither claim ownership of the typed
+ * shape.
+ *
+ * `class` declares the class this PathType identifies via its raw
+ * class-path string. Used by adapter-side dispatch — the Cypher
+ * walker branches per label by reading `gm.nodeInfoForClass(type.class)`.
+ * `null` for universal types that identify any node (`IdPath`,
+ * `AbsolutePath`, `RelativePath`, `InstanceMethodPath`).
+ *
+ * Held as a string (not a typed `ClassPath`) so `nav` stays self-
+ * contained — domain concepts don't leak into the path-language
+ * infrastructure. Construction sites with a `ClassPath` in scope pass
+ * `classPath.raw`.
+ */
+export interface PathType<T extends Path = Path> {
+    readonly name: string;
+    readonly segments: readonly SchemeSegment[];
+    /**
+     * Raw class-path string identifying the node class this PathType
+     * matches, or `null` if the type is universal. Opaque to nav;
+     * resolved by adapters/registries that know the domain layout.
+     */
+    readonly class: string | null;
+    /**
+     * Refine match beyond pure segment composition. Default behaviour
+     * (segments exhaust the steps) lives in `chain.ts:matchesChain`.
+     * Types that need stricter narrowing (e.g. ClassPath rejecting
+     * `class.X.Y` dotted member names) override this hook.
+     */
+    matches?(steps: readonly Step[]): boolean;
+    /**
+     * Build the typed wrapper from validated steps and the original raw
+     * input string.
+     */
+    build(steps: readonly Step[], raw: string): T;
+}
+//# sourceMappingURL=path-type.d.ts.map

package/dist/graph/nav/path/kinds/path-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-type.d.ts","sourceRoot":"","sources":["../../../../../graph/nav/path/kinds/path-type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI;IAC7C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IAErB,QAAQ,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,CAAA;IAE3C;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IAE7B;;;;;OAKG;IACH,OAAO,CAAC,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,OAAO,CAAA;IAEzC;;;OAGG;IACH,KAAK,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,CAAA;CAC9C"}

package/dist/graph/nav/path/kinds/path-type.js

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

package/dist/graph/nav/path/kinds/path-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-type.js","sourceRoot":"","sources":["../../../../../graph/nav/path/kinds/path-type.ts"],"names":[],"mappings":""}

package/dist/graph/nav/path/kinds/registry.d.ts

@@ -0,0 +1,51 @@
+import type { Step } from '../../ast/step';
+import type { PathType } from './path-type';
+/**
+ * Registry of typed-path classes available for parsing and identifying.
+ *
+ * Detection picks the *most specific* type that matches a Step[] — when
+ * multiple types match, the one whose segments cover the longest run
+ * wins, with ties broken by registration order (later wins). PathTypes
+ * register themselves at boot; tests use `_reset()` for isolation.
+ *
+ * Detection is purely structural: the parsed Step[] carries every bit
+ * of information about the path's shape (in particular, an absolute
+ * path's leading {@link RootAnchor} distinguishes it from a relative
+ * path's bare-traversal sequence).
+ *
+ * **Class invariant.** A PathType with a non-null `class` claims
+ * exclusive ownership of that class — at most one such PathType per
+ * class. Registration throws on collision rather than silently
+ * overshadowing. Universal types (`class === null`) coexist freely.
+ * Consumers that need the class → PathType mapping (semantic-target
+ * reconstruction, per-class Cypher branch dispatch) read it from
+ * {@link byClass} / {@link byClassMap}; both code paths therefore
+ * share a single source of truth and cannot diverge by iteration order.
+ */
+export declare class PathTypeRegistry {
+    private static readonly _types;
+    private static readonly _byClass;
+    static register(type: PathType): void;
+    static all(): readonly PathType[];
+    /**
+     * The unique PathType claiming `cls`, or `null` if no PathType
+     * registered against this class. O(1).
+     */
+    static byClass(cls: string): PathType | null;
+    /**
+     * Live view of the class → PathType index. Consumers that need to
+     * iterate one branch per class (e.g., the Cypher walker) drive off
+     * this map so they share dispatch with {@link byClass} reverse
+     * lookups by construction.
+     */
+    static byClassMap(): ReadonlyMap<string, PathType>;
+    /**
+     * Find the most-specific PathType whose `matches` accepts these
+     * steps. Returns `undefined` when no type matches — callers wrap the
+     * step list in the base {@link Path} class as a fallback.
+     */
+    static detect(steps: readonly Step[]): PathType | undefined;
+    /** Reset registry state. For testing only. */
+    static _reset(): void;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/graph/nav/path/kinds/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../../graph/nav/path/kinds/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAI3C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAiB;IAC/C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAA8B;IAE9D,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAYpC;IAED,MAAM,CAAC,GAAG,IAAI,SAAS,QAAQ,EAAE,CAEhC;IAED;;;OAGG;IACH,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAE3C;IAED;;;;;OAKG;IACH,MAAM,CAAC,UAAU,IAAI,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,CAEjD;IAED;;;;OAIG;IACH,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,QAAQ,GAAG,SAAS,CAc1D;IAED,8CAA8C;IAC9C,MAAM,CAAC,MAAM,IAAI,IAAI,CAGpB;CACF"}

package/dist/graph/nav/path/kinds/registry.js

@@ -0,0 +1,85 @@
+import { matchesChain, chainSpan } from './chain';
+/**
+ * Registry of typed-path classes available for parsing and identifying.
+ *
+ * Detection picks the *most specific* type that matches a Step[] — when
+ * multiple types match, the one whose segments cover the longest run
+ * wins, with ties broken by registration order (later wins). PathTypes
+ * register themselves at boot; tests use `_reset()` for isolation.
+ *
+ * Detection is purely structural: the parsed Step[] carries every bit
+ * of information about the path's shape (in particular, an absolute
+ * path's leading {@link RootAnchor} distinguishes it from a relative
+ * path's bare-traversal sequence).
+ *
+ * **Class invariant.** A PathType with a non-null `class` claims
+ * exclusive ownership of that class — at most one such PathType per
+ * class. Registration throws on collision rather than silently
+ * overshadowing. Universal types (`class === null`) coexist freely.
+ * Consumers that need the class → PathType mapping (semantic-target
+ * reconstruction, per-class Cypher branch dispatch) read it from
+ * {@link byClass} / {@link byClassMap}; both code paths therefore
+ * share a single source of truth and cannot diverge by iteration order.
+ */
+export class PathTypeRegistry {
+    static _types = [];
+    static _byClass = new Map();
+    static register(type) {
+        if (PathTypeRegistry._types.includes(type))
+            return;
+        if (type.class !== null) {
+            const existing = PathTypeRegistry._byClass.get(type.class);
+            if (existing !== undefined) {
+                throw new Error(`PathTypeRegistry.register: class "${type.class}" is already claimed by PathType "${existing.name}"; cannot register "${type.name}". Each non-universal PathType must claim a unique class.`);
+            }
+            PathTypeRegistry._byClass.set(type.class, type);
+        }
+        PathTypeRegistry._types.push(type);
+    }
+    static all() {
+        return PathTypeRegistry._types;
+    }
+    /**
+     * The unique PathType claiming `cls`, or `null` if no PathType
+     * registered against this class. O(1).
+     */
+    static byClass(cls) {
+        return PathTypeRegistry._byClass.get(cls) ?? null;
+    }
+    /**
+     * Live view of the class → PathType index. Consumers that need to
+     * iterate one branch per class (e.g., the Cypher walker) drive off
+     * this map so they share dispatch with {@link byClass} reverse
+     * lookups by construction.
+     */
+    static byClassMap() {
+        return PathTypeRegistry._byClass;
+    }
+    /**
+     * Find the most-specific PathType whose `matches` accepts these
+     * steps. Returns `undefined` when no type matches — callers wrap the
+     * step list in the base {@link Path} class as a fallback.
+     */
+    static detect(steps) {
+        let best;
+        let bestSpan = -1;
+        for (let i = PathTypeRegistry._types.length - 1; i >= 0; i--) {
+            const t = PathTypeRegistry._types[i];
+            const matched = (t.matches ?? ((s) => matchesChain(t.segments, s)))(steps);
+            if (!matched)
+                continue;
+            const span = chainSpan(t.segments, steps);
+            if (span > bestSpan) {
+                best = t;
+                bestSpan = span;
+            }
+        }
+        return best;
+    }
+    /** Reset registry state. For testing only. */
+    static _reset() {
+        PathTypeRegistry._types.length = 0;
+        PathTypeRegistry._byClass.clear();
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/graph/nav/path/kinds/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../../../graph/nav/path/kinds/registry.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAEjD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,gBAAgB;IACnB,MAAM,CAAU,MAAM,GAAe,EAAE,CAAA;IACvC,MAAM,CAAU,QAAQ,GAAG,IAAI,GAAG,EAAoB,CAAA;IAE9D,MAAM,CAAC,QAAQ,CAAC,IAAc;QAC5B,IAAI,gBAAgB,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC;YAAE,OAAM;QAClD,IAAI,IAAI,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;YACxB,MAAM,QAAQ,GAAG,gBAAgB,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YAC1D,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;gBAC3B,MAAM,IAAI,KAAK,CACb,qCAAqC,IAAI,CAAC,KAAK,qCAAqC,QAAQ,CAAC,IAAI,uBAAuB,IAAI,CAAC,IAAI,2DAA2D,CAC7L,CAAA;YACH,CAAC;YACD,gBAAgB,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,CAAA;QACjD,CAAC;QACD,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACpC,CAAC;IAED,MAAM,CAAC,GAAG;QACR,OAAO,gBAAgB,CAAC,MAAM,CAAA;IAChC,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,OAAO,CAAC,GAAW;QACxB,OAAO,gBAAgB,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,CAAA;IACnD,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,UAAU;QACf,OAAO,gBAAgB,CAAC,QAAQ,CAAA;IAClC,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,MAAM,CAAC,KAAsB;QAClC,IAAI,IAA0B,CAAA;QAC9B,IAAI,QAAQ,GAAG,CAAC,CAAC,CAAA;QACjB,KAAK,IAAI,CAAC,GAAG,gBAAgB,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC7D,MAAM,CAAC,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAE,CAAA;YACrC,MAAM,OAAO,GAAG,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;YAC1E,IAAI,CAAC,OAAO;gBAAE,SAAQ;YACtB,MAAM,IAAI,GAAG,SAAS,CAAC,CAAC,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAA;YACzC,IAAI,IAAI,GAAG,QAAQ,EAAE,CAAC;gBACpB,IAAI,GAAG,CAAC,CAAA;gBACR,QAAQ,GAAG,IAAI,CAAA;YACjB,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAA;IACb,CAAC;IAED,8CAA8C;IAC9C,MAAM,CAAC,MAAM;QACX,gBAAgB,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAA;QAClC,gBAAgB,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAA;IACnC,CAAC;CACF"}