@astrale-os/kernel-core 0.4.1

package/dist/graph/nav/ast/step/reverse.js

@@ -0,0 +1,58 @@
+import { predicateEqual } from '../predicate/operations';
+/**
+ * Reverse a single step. Anchors are their own reverse (direction-free);
+ * traversals swap `from` and `to`, preserving edgeClass and predicate.
+ *
+ * Involutive: `reverseStep(reverseStep(s)) === s` (structural equality).
+ */
+export function reverseStep(step) {
+    if (step.kind === 'anchor')
+        return step;
+    return {
+        kind: 'traversal',
+        edgeClass: step.edgeClass,
+        from: step.to,
+        to: step.from,
+        ...(step.predicate !== undefined && { predicate: step.predicate }),
+    };
+}
+/**
+ * Reverse a step sequence — reverse order AND reverse each step. This is
+ * an involutive anti-homomorphism over the free monoid of steps:
+ *   reverseSteps(reverseSteps(σ)) === σ
+ *   reverseSteps(σ · τ) === reverseSteps(τ) · reverseSteps(σ)
+ */
+export function reverseSteps(steps) {
+    const out = [];
+    for (let i = steps.length - 1; i >= 0; i--) {
+        out.push(reverseStep(steps[i]));
+    }
+    return out;
+}
+/**
+ * Deep structural equality on step sequences. Compares kind, edgeClass,
+ * from/to, anchor id, and predicate by structural shape.
+ */
+export function stepsEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (!stepEqual(a[i], b[i]))
+            return false;
+    }
+    return true;
+}
+function stepEqual(a, b) {
+    if (a.kind !== b.kind)
+        return false;
+    if (a.kind === 'anchor')
+        return a.id === b.id;
+    const at = a;
+    const bt = b;
+    if (at.edgeClass !== bt.edgeClass)
+        return false;
+    if (at.from !== bt.from || at.to !== bt.to)
+        return false;
+    return predicateEqual(at.predicate, bt.predicate);
+}
+//# sourceMappingURL=reverse.js.map

package/dist/graph/nav/ast/step/reverse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverse.js","sourceRoot":"","sources":["../../../../../graph/nav/ast/step/reverse.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAExD;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,IAAU;IACpC,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAA;IACvC,OAAO;QACL,IAAI,EAAE,WAAW;QACjB,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,IAAI,EAAE,IAAI,CAAC,EAAE;QACb,EAAE,EAAE,IAAI,CAAC,IAAI;QACb,GAAG,CAAC,IAAI,CAAC,SAAS,KAAK,SAAS,IAAI,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC;KACnE,CAAA;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,KAAsB;IACjD,MAAM,GAAG,GAAW,EAAE,CAAA;IACtB,KAAK,IAAI,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3C,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAE,CAAC,CAAC,CAAA;IAClC,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,UAAU,CAAC,CAAkB,EAAE,CAAkB;IAC/D,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM;QAAE,OAAO,KAAK,CAAA;IACvC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAClC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAE,EAAE,CAAC,CAAC,CAAC,CAAE,CAAC;YAAE,OAAO,KAAK,CAAA;IAC5C,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC;AAED,SAAS,SAAS,CAAC,CAAO,EAAE,CAAO;IACjC,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI;QAAE,OAAO,KAAK,CAAA;IACnC,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ;QAAE,OAAO,CAAC,CAAC,EAAE,KAAM,CAAc,CAAC,EAAE,CAAA;IAC3D,MAAM,EAAE,GAAG,CAAc,CAAA;IACzB,MAAM,EAAE,GAAG,CAAc,CAAA;IACzB,IAAI,EAAE,CAAC,SAAS,KAAK,EAAE,CAAC,SAAS;QAAE,OAAO,KAAK,CAAA;IAC/C,IAAI,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE;QAAE,OAAO,KAAK,CAAA;IACxD,OAAO,cAAc,CAAC,EAAE,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,CAAA;AACnD,CAAC"}

package/dist/graph/nav/ast/step/traversal.d.ts

@@ -0,0 +1,39 @@
+import type { Predicate } from '../predicate/types';
+/**
+ * Follow edges of a given class, from one role to another, with optional
+ * filter.
+ *
+ * `edgeClass` names the class of edge to walk. Two surface forms are
+ * accepted (decoupled at the IR level — adapters resolve via an
+ * `EdgeResolver`):
+ *  - **Sugar** — well-known shorthand like `"has_parent"`,
+ *    `"installed_in"`, `"of_domain"`, `"method_of"`, `"instance_of"`,
+ *    `"from"`, `"to"`. Resolved against a registry populated when the
+ *    kernel-meta domain compiles.
+ *  - **Class path** — full domain-qualified ClassPath raw form like
+ *    `"/:kernel.astrale.ai:class.has_parent"` or
+ *    `"/:messaging.acme:class.send"`. Always works regardless of
+ *    sugar.
+ *
+ * The IR stays a string so universal grammars / segments can produce
+ * steps without a `CompiledDomain` in scope. Domain awareness lives in
+ * the resolver layer.
+ */
+export interface Traversal {
+    readonly kind: 'traversal';
+    readonly edgeClass: string;
+    readonly from: string;
+    readonly to: string;
+    readonly predicate?: Predicate;
+}
+/** Construction helper: outbound binary edge (source → target). */
+export declare const OUTBOUND: {
+    readonly from: 'source';
+    readonly to: 'target';
+};
+/** Construction helper: inbound binary edge (target → source). */
+export declare const INBOUND: {
+    readonly from: 'target';
+    readonly to: 'source';
+};
+//# sourceMappingURL=traversal.d.ts.map

package/dist/graph/nav/ast/step/traversal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traversal.d.ts","sourceRoot":"","sources":["../../../../../graph/nav/ast/step/traversal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAEnD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAA;CAC/B;AAED,mEAAmE;AACnE,eAAO,MAAM,QAAQ;aAAK,IAAI,EAAE,QAAQ;aAAE,EAAE,EAAE,QAAQ;CAAW,CAAA;AAEjE,kEAAkE;AAClE,eAAO,MAAM,OAAO;aAAK,IAAI,EAAE,QAAQ;aAAE,EAAE,EAAE,QAAQ;CAAW,CAAA"}

package/dist/graph/nav/ast/step/traversal.js

@@ -0,0 +1,5 @@
+/** Construction helper: outbound binary edge (source → target). */
+export const OUTBOUND = { from: 'source', to: 'target' };
+/** Construction helper: inbound binary edge (target → source). */
+export const INBOUND = { from: 'target', to: 'source' };
+//# sourceMappingURL=traversal.js.map

package/dist/graph/nav/ast/step/traversal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"traversal.js","sourceRoot":"","sources":["../../../../../graph/nav/ast/step/traversal.ts"],"names":[],"mappings":"AA8BA,mEAAmE;AACnE,MAAM,CAAC,MAAM,QAAQ,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,QAAQ,EAAW,CAAA;AAEjE,kEAAkE;AAClE,MAAM,CAAC,MAAM,OAAO,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,QAAQ,EAAW,CAAA"}

package/dist/graph/nav/grammar/core.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Core grammar — the universal vocabulary every path/query expression
+ * is parsed against. Single-character literals reserved by the path
+ * language: `@` (id anchor), `~` (traversal), `<` (inbound prefix),
+ * `()` (filter delimiters), `=` `&` `|` `!` (predicate operators).
+ *
+ * Grammar extensions (`./` for relative, `:` for domain, `::` for
+ * instance-method, …) compose *on top of* this core vocabulary by
+ * contributing additional `TokenDefinition`s. The lexer recognises
+ * core + extension tokens together via `buildTokenTable` (see
+ * `lex/table.ts`).
+ */
+export interface CoreTokens {
+    readonly idPrefix: string;
+    readonly traversalOp: string;
+    readonly inboundStart: string;
+    readonly filterOpen: string;
+    readonly filterClose: string;
+    readonly filterAssign: string;
+    readonly filterAnd: string;
+    readonly filterOr: string;
+    readonly filterNot: string;
+}
+export declare const CORE_TOKENS: CoreTokens;
+//# sourceMappingURL=core.d.ts.map

package/dist/graph/nav/grammar/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../../graph/nav/grammar/core.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAED,eAAO,MAAM,WAAW,EAAE,UAUxB,CAAA"}

package/dist/graph/nav/grammar/core.js

@@ -0,0 +1,12 @@
+export const CORE_TOKENS = Object.freeze({
+    idPrefix: '@',
+    traversalOp: '~',
+    inboundStart: '<',
+    filterOpen: '(',
+    filterClose: ')',
+    filterAssign: '=',
+    filterAnd: '&',
+    filterOr: '|',
+    filterNot: '!',
+});
+//# sourceMappingURL=core.js.map

package/dist/graph/nav/grammar/core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../../graph/nav/grammar/core.ts"],"names":[],"mappings":"AAwBA,MAAM,CAAC,MAAM,WAAW,GAAe,MAAM,CAAC,MAAM,CAAC;IACnD,QAAQ,EAAE,GAAG;IACb,WAAW,EAAE,GAAG;IAChB,YAAY,EAAE,GAAG;IACjB,UAAU,EAAE,GAAG;IACf,WAAW,EAAE,GAAG;IAChB,YAAY,EAAE,GAAG;IACjB,SAAS,EAAE,GAAG;IACd,QAAQ,EAAE,GAAG;IACb,SAAS,EAAE,GAAG;CACf,CAAC,CAAA"}

package/dist/graph/nav/grammar/extension.d.ts

@@ -0,0 +1,35 @@
+import type { Step } from '../ast/step';
+import type { TokenDefinition } from '../lex/token';
+import type { TokenStream } from '../parse/stream';
+export interface PrefixResult {
+    /** Whether the parsed path is relative (starts with `./` or `.`). */
+    readonly isRelative: boolean;
+}
+/**
+ * Sugar layer for the path language.
+ *
+ * Owns one bidirectional translation: characters ↔ Step[]. Pure of any
+ * graph access — extensions cannot inspect a graph and cannot infer
+ * scheme membership; they are strictly a presentation layer over the
+ * Step[] IR.
+ *
+ * `parseStep` returns a (possibly empty) sequence of steps when its head
+ * matches the stream, or `null` when it doesn't recognize the head and
+ * defers to other extensions. Returning `[]` is meaningful: the
+ * extension consumed sugar (e.g. a leading `/`) without producing a
+ * step.
+ *
+ * `parsePrefix` is an optional hook that runs once before the main
+ * step-loop. The relative-tree extension uses it to consume `./` and
+ * mark the resulting path as relative. Tried last-registered-first;
+ * the first extension to claim wins.
+ */
+export interface GrammarExtension {
+    readonly name: string;
+    readonly tokens: readonly TokenDefinition[];
+    parsePrefix?(stream: TokenStream): PrefixResult | null;
+    parseStep(stream: TokenStream): readonly Step[] | null;
+    serializeStep(step: Step, prev: Step | null): string | null;
+    serializePrefix?(isRelative: boolean): string | null;
+}
+//# sourceMappingURL=extension.d.ts.map

package/dist/graph/nav/grammar/extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension.d.ts","sourceRoot":"","sources":["../../../../graph/nav/grammar/extension.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAElD,MAAM,WAAW,YAAY;IAC3B,qEAAqE;IACrE,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;CAC7B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAA;IAE3C,WAAW,CAAC,CAAC,MAAM,EAAE,WAAW,GAAG,YAAY,GAAG,IAAI,CAAA;IACtD,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,IAAI,EAAE,GAAG,IAAI,CAAA;IACtD,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAAA;IAC3D,eAAe,CAAC,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAAA;CACrD"}

package/dist/graph/nav/grammar/extension.js

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

package/dist/graph/nav/grammar/extension.js.map

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

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

@@ -0,0 +1,7 @@
+export type { CoreTokens } from './core';
+export { CORE_TOKENS } from './core';
+export type { TokenDefinition } from '../lex/token';
+export type { GrammarExtension, PrefixResult } from './extension';
+export { GrammarRegistry } from './registry';
+export { parseSteps, parseStepsWith, type PathParseResult } from '../parse/steps';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../graph/nav/grammar/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AACpC,YAAY,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AACnD,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AACjE,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAC5C,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAA"}

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

@@ -0,0 +1,4 @@
+export { CORE_TOKENS } from './core';
+export { GrammarRegistry } from './registry';
+export { parseSteps, parseStepsWith } from '../parse/steps';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../graph/nav/grammar/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AAGpC,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAC5C,OAAO,EAAE,UAAU,EAAE,cAAc,EAAwB,MAAM,gBAAgB,CAAA"}

package/dist/graph/nav/grammar/registry.d.ts

@@ -0,0 +1,25 @@
+import type { Step } from '#graph/nav/path/step';
+import type { GrammarExtension } from './extension';
+/**
+ * Single source of truth for registered grammar extensions.
+ *
+ * The registry caches the merged token list; registration invalidates
+ * the cache so the next parse picks up the new tokens. Tests call
+ * `_reset()` to drop registrations between runs.
+ */
+export declare class GrammarRegistry {
+    private static readonly _extensions;
+    static register(ext: GrammarExtension): void;
+    static extensions(): readonly GrammarExtension[];
+    /**
+     * Try every extension's `serializeStep` (last registered first).
+     * `prev` is the previous step in the surrounding `Step[]` (or `null`
+     * for the first step) — extensions that need cross-step context
+     * (instance-method `::method` sugar) read it to disambiguate; others
+     * ignore it.
+     */
+    static serializeStep(step: Step, prev: Step | null): string | null;
+    /** Reset registry state. For testing only. */
+    static _reset(): void;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/graph/nav/grammar/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../graph/nav/grammar/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;AAEhD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD;;;;;;GAMG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAyB;IAE5D,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI,CAG3C;IAED,MAAM,CAAC,UAAU,IAAI,SAAS,gBAAgB,EAAE,CAE/C;IAED;;;;;;OAMG;IACH,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAMjE;IAED,8CAA8C;IAC9C,MAAM,CAAC,MAAM,IAAI,IAAI,CAEpB;CACF"}

package/dist/graph/nav/grammar/registry.js

@@ -0,0 +1,38 @@
+/**
+ * Single source of truth for registered grammar extensions.
+ *
+ * The registry caches the merged token list; registration invalidates
+ * the cache so the next parse picks up the new tokens. Tests call
+ * `_reset()` to drop registrations between runs.
+ */
+export class GrammarRegistry {
+    static _extensions = [];
+    static register(ext) {
+        if (GrammarRegistry._extensions.includes(ext))
+            return;
+        GrammarRegistry._extensions.push(ext);
+    }
+    static extensions() {
+        return GrammarRegistry._extensions;
+    }
+    /**
+     * Try every extension's `serializeStep` (last registered first).
+     * `prev` is the previous step in the surrounding `Step[]` (or `null`
+     * for the first step) — extensions that need cross-step context
+     * (instance-method `::method` sugar) read it to disambiguate; others
+     * ignore it.
+     */
+    static serializeStep(step, prev) {
+        for (let i = GrammarRegistry._extensions.length - 1; i >= 0; i--) {
+            const out = GrammarRegistry._extensions[i].serializeStep(step, prev);
+            if (out !== null)
+                return out;
+        }
+        return null;
+    }
+    /** Reset registry state. For testing only. */
+    static _reset() {
+        GrammarRegistry._extensions.length = 0;
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/graph/nav/grammar/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../../graph/nav/grammar/registry.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,MAAM,OAAO,eAAe;IAClB,MAAM,CAAU,WAAW,GAAuB,EAAE,CAAA;IAE5D,MAAM,CAAC,QAAQ,CAAC,GAAqB;QACnC,IAAI,eAAe,CAAC,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC;YAAE,OAAM;QACrD,eAAe,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;IACvC,CAAC;IAED,MAAM,CAAC,UAAU;QACf,OAAO,eAAe,CAAC,WAAW,CAAA;IACpC,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,aAAa,CAAC,IAAU,EAAE,IAAiB;QAChD,KAAK,IAAI,CAAC,GAAG,eAAe,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YACjE,MAAM,GAAG,GAAG,eAAe,CAAC,WAAW,CAAC,CAAC,CAAE,CAAC,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;YACrE,IAAI,GAAG,KAAK,IAAI;gBAAE,OAAO,GAAG,CAAA;QAC9B,CAAC;QACD,OAAO,IAAI,CAAA;IACb,CAAC;IAED,8CAA8C;IAC9C,MAAM,CAAC,MAAM;QACX,eAAe,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAA;IACxC,CAAC;CACF"}

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

@@ -0,0 +1,36 @@
+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 { predicateMatches, predicateEqual } from './ast/predicate/operations';
+export type { Slug } from './ast/slug';
+export { slugSchema, SLUG_PROPERTY } from './ast/slug';
+export type { Token, TokenKind, CoreTokenKind, TokenDefinition } from './lex/token';
+export type { TokenTable, TokenEntry } from './lex/table';
+export { buildTokenTable } from './lex/table';
+export type { CoreTokens } from './grammar/core';
+export { CORE_TOKENS } from './grammar/core';
+export { tokenize } from './lex/tokenize';
+export type { GrammarExtension, PrefixResult } from './grammar/extension';
+export { GrammarRegistry } from './grammar/registry';
+export { TokenStream } from './parse/stream';
+export { parseSteps, parseStepsWith, type PathParseResult } from './parse/steps';
+export { parsePredicate, PredicateParseError } from './parse/predicate';
+export { type ValidationError, type ValidationResult, validResult, invalidResult, } from './parse/validation';
+export { serializeStep, serializeSteps, serializeStepCore } from './serialize/steps';
+export { serializePredicate } from './serialize/predicate';
+export type { Hop, SchemeSegment, SingleHop, RecursiveHop } from './scheme/segment';
+export { span, walk, type SegmentWalkResult } from './scheme';
+export { traversalFromHop, reconstructSteps } from './scheme/slug';
+export { SchemeRegistry } from './scheme/registry';
+export { Path, toPath } from './path/path';
+export { parsePath, safeParsePath, type ParsePathResult } from './path/parse';
+export { buildPath } from './path/build';
+export type { PathType } from './path/kinds/path-type';
+export { PathTypeRegistry } from './path/kinds/registry';
+export { matchesChain, chainSpan, walkChain } from './path/kinds/chain';
+export { IdPath, idPathType, registerIdPath } from './path/kinds/id-path';
+export { PathParseError, IdentifyError, PathNotFoundError, AmbiguousPathError, MissingContextError, } from './path/errors';
+export { pathLike, pathSchema, idPathSchema, PathValidationError } from './path/zod';
+export type { PathCtor, PathValidationErrorKind, PathValidationIssue } from './path/zod';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/graph/nav/index.js

@@ -0,0 +1,32 @@
+// Curated public surface for `#graph/nav`.
+// Layout: ast (Step + Predicate) · slug · lex · grammar · parse · serialize · scheme · path.
+// The path/index.ts barrel also re-exports most of these — this file is the
+// canonical surface for the top-level `#graph/nav` subpath.
+export { OUTBOUND, INBOUND, ROOT_ANCHOR, idAnchor, isRootAnchor } from './ast/step';
+export { reverseStep, reverseSteps, stepsEqual } from './ast/step/reverse';
+export { predicateMatches, predicateEqual } from './ast/predicate/operations';
+export { slugSchema, SLUG_PROPERTY } from './ast/slug';
+export { buildTokenTable } from './lex/table';
+export { CORE_TOKENS } from './grammar/core';
+export { tokenize } from './lex/tokenize';
+export { GrammarRegistry } from './grammar/registry';
+// ─── Parse / Serialize ──────────────────────────────
+export { TokenStream } from './parse/stream';
+export { parseSteps, parseStepsWith } from './parse/steps';
+export { parsePredicate, PredicateParseError } from './parse/predicate';
+export { validResult, invalidResult, } from './parse/validation';
+export { serializeStep, serializeSteps, serializeStepCore } from './serialize/steps';
+export { serializePredicate } from './serialize/predicate';
+export { span, walk } from './scheme';
+export { traversalFromHop, reconstructSteps } from './scheme/slug';
+export { SchemeRegistry } from './scheme/registry';
+// ─── Path sibling ───────────────────────────────────
+export { Path, toPath } from './path/path';
+export { parsePath, safeParsePath } from './path/parse';
+export { buildPath } from './path/build';
+export { PathTypeRegistry } from './path/kinds/registry';
+export { matchesChain, chainSpan, walkChain } from './path/kinds/chain';
+export { IdPath, idPathType, registerIdPath } from './path/kinds/id-path';
+export { PathParseError, IdentifyError, PathNotFoundError, AmbiguousPathError, MissingContextError, } from './path/errors';
+export { pathLike, pathSchema, idPathSchema, PathValidationError } from './path/zod';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../graph/nav/index.ts"],"names":[],"mappings":"AAAA,2CAA2C;AAC3C,6FAA6F;AAC7F,4EAA4E;AAC5E,4DAA4D;AAI5D,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AACnF,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAW1E,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAI7E,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAKtD,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAE7C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAIzC,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAEpD,uDAAuD;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,EAAE,UAAU,EAAE,cAAc,EAAwB,MAAM,eAAe,CAAA;AAChF,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AACvE,OAAO,EAGL,WAAW,EACX,aAAa,GACd,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AACpF,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAI1D,OAAO,EAAE,IAAI,EAAE,IAAI,EAA0B,MAAM,UAAU,CAAA;AAC7D,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAElD,uDAAuD;AACvD,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,aAAa,EAAwB,MAAM,cAAc,CAAA;AAC7E,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAGxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AACvE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAEzE,OAAO,EACL,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,eAAe,CAAA;AAEtB,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA"}

package/dist/graph/nav/lex/table.d.ts

@@ -0,0 +1,16 @@
+import type { CoreTokens } from '../grammar/core';
+import type { TokenDefinition } from './token';
+/** Core tokens + extension-registered tokens, ready for the lexer. */
+export interface TokenTable {
+    readonly core: CoreTokens;
+    /** All single-char or multi-char tokens to recognize (core + extensions), sorted by priority descending then length descending. */
+    readonly tokens: readonly TokenEntry[];
+}
+export interface TokenEntry {
+    readonly chars: string;
+    readonly kind: string;
+    readonly priority: number;
+}
+/** Build a TokenTable from core tokens + extension token definitions. */
+export declare function buildTokenTable(core: CoreTokens, extensionTokens: readonly TokenDefinition[]): TokenTable;
+//# sourceMappingURL=table.d.ts.map

package/dist/graph/nav/lex/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../../graph/nav/lex/table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C,sEAAsE;AACtE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,mIAAmI;IACnI,QAAQ,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAA;CACvC;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AAED,yEAAyE;AACzE,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,eAAe,EAAE,SAAS,eAAe,EAAE,GAC1C,UAAU,CAwBZ"}

package/dist/graph/nav/lex/table.js

@@ -0,0 +1,24 @@
+/** Build a TokenTable from core tokens + extension token definitions. */
+export function buildTokenTable(core, extensionTokens) {
+    const coreTokens = [
+        { chars: core.idPrefix, kind: 'AT', priority: 0 },
+        { chars: core.traversalOp, kind: 'TILDE', priority: 0 },
+        { chars: core.inboundStart, kind: 'LT', priority: 0 },
+        { chars: core.filterOpen, kind: 'PAREN_OPEN', priority: 0 },
+        { chars: core.filterClose, kind: 'PAREN_CLOSE', priority: 0 },
+        { chars: core.filterAssign, kind: 'ASSIGN', priority: 0 },
+        { chars: core.filterAnd, kind: 'AND', priority: 0 },
+        { chars: core.filterOr, kind: 'OR', priority: 0 },
+        { chars: core.filterNot, kind: 'NOT', priority: 0 },
+    ];
+    const extTokens = extensionTokens.map((t) => ({
+        chars: t.chars,
+        kind: t.kind,
+        priority: t.priority ?? 0,
+    }));
+    const all = [...coreTokens, ...extTokens];
+    // Sort: higher priority first, then longer chars first (so './' beats '.')
+    all.sort((a, b) => b.priority - a.priority || b.chars.length - a.chars.length);
+    return { core, tokens: all };
+}
+//# sourceMappingURL=table.js.map

package/dist/graph/nav/lex/table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.js","sourceRoot":"","sources":["../../../../graph/nav/lex/table.ts"],"names":[],"mappings":"AAgBA,yEAAyE;AACzE,MAAM,UAAU,eAAe,CAC7B,IAAgB,EAChB,eAA2C;IAE3C,MAAM,UAAU,GAAiB;QAC/B,EAAE,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE;QACjD,EAAE,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,EAAE;QACvD,EAAE,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE;QACrD,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,CAAC,EAAE;QAC3D,EAAE,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC,EAAE;QAC7D,EAAE,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,EAAE;QACzD,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,EAAE;QACnD,EAAE,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE;QACjD,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,EAAE;KACpD,CAAA;IAED,MAAM,SAAS,GAAiB,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAC1D,KAAK,EAAE,CAAC,CAAC,KAAK;QACd,IAAI,EAAE,CAAC,CAAC,IAAI;QACZ,QAAQ,EAAE,CAAC,CAAC,QAAQ,IAAI,CAAC;KAC1B,CAAC,CAAC,CAAA;IAEH,MAAM,GAAG,GAAG,CAAC,GAAG,UAAU,EAAE,GAAG,SAAS,CAAC,CAAA;IACzC,2EAA2E;IAC3E,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IAE9E,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,CAAA;AAC9B,CAAC"}

package/dist/graph/nav/lex/token.d.ts

@@ -0,0 +1,23 @@
+/** Well-known core token kinds. Extensions add string-typed kinds. */
+export type CoreTokenKind = 'AT' | 'TILDE' | 'PAREN_OPEN' | 'PAREN_CLOSE' | 'ASSIGN' | 'LT' | 'GT' | 'AND' | 'OR' | 'NOT' | 'TEXT';
+/** Token kind is a string — core kinds are well-known, extensions add their own. */
+export type TokenKind = CoreTokenKind | (string & {});
+export interface Token {
+    readonly kind: TokenKind;
+    readonly value: string;
+    readonly position: number;
+}
+/**
+ * A token that an extension contributes to the lexer.
+ *
+ * - `chars` is the literal sequence the lexer must recognize.
+ * - `kind` is the token-kind tag the parser dispatches on.
+ * - `priority` resolves overlap (higher first); ties break by `chars`
+ *   length descending, so `'./'` beats `'.'` and `'::'` beats `':'`.
+ */
+export interface TokenDefinition {
+    readonly chars: string;
+    readonly kind: string;
+    readonly priority?: number;
+}
+//# sourceMappingURL=token.d.ts.map

package/dist/graph/nav/lex/token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../../../../graph/nav/lex/token.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,MAAM,MAAM,aAAa,GACrB,IAAI,GACJ,OAAO,GACP,YAAY,GACZ,aAAa,GACb,QAAQ,GACR,IAAI,GACJ,IAAI,GACJ,KAAK,GACL,IAAI,GACJ,KAAK,GACL,MAAM,CAAA;AAEV,oFAAoF;AACpF,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAA;AAErD,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAC3B"}

package/dist/graph/nav/lex/token.js

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

package/dist/graph/nav/lex/token.js.map

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

package/dist/graph/nav/lex/tokenize.d.ts

@@ -0,0 +1,5 @@
+import type { TokenTable } from './table';
+import type { Token } from './token';
+/** Tokenize a raw expression string using the merged token table (core + extension tokens). */
+export declare function tokenize(raw: string, table: TokenTable): Token[];
+//# sourceMappingURL=tokenize.d.ts.map

package/dist/graph/nav/lex/tokenize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenize.d.ts","sourceRoot":"","sources":["../../../../graph/nav/lex/tokenize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC,+FAA+F;AAC/F,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,KAAK,EAAE,CAkChE"}

package/dist/graph/nav/lex/tokenize.js

@@ -0,0 +1,40 @@
+/** Tokenize a raw expression string using the merged token table (core + extension tokens). */
+export function tokenize(raw, table) {
+    const tokens = [];
+    let pos = 0;
+    while (pos < raw.length) {
+        // Skip whitespace between tokens
+        if (raw[pos] === ' ' || raw[pos] === '\t') {
+            pos++;
+            continue;
+        }
+        const matched = matchToken(raw, pos, table);
+        if (matched) {
+            tokens.push({ kind: matched.kind, value: matched.chars, position: pos });
+            pos += matched.chars.length;
+            continue;
+        }
+        // Accumulate TEXT until the next grammar token or whitespace
+        const start = pos;
+        while (pos < raw.length &&
+            raw[pos] !== ' ' &&
+            raw[pos] !== '\t' &&
+            !matchToken(raw, pos, table)) {
+            pos++;
+        }
+        if (pos > start) {
+            tokens.push({ kind: 'TEXT', value: raw.slice(start, pos), position: start });
+        }
+    }
+    return tokens;
+}
+function matchToken(raw, pos, table) {
+    // Tokens are sorted by priority desc then length desc — first match wins
+    for (const token of table.tokens) {
+        if (raw.startsWith(token.chars, pos)) {
+            return { kind: token.kind, chars: token.chars };
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=tokenize.js.map

package/dist/graph/nav/lex/tokenize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenize.js","sourceRoot":"","sources":["../../../../graph/nav/lex/tokenize.ts"],"names":[],"mappings":"AAGA,+FAA+F;AAC/F,MAAM,UAAU,QAAQ,CAAC,GAAW,EAAE,KAAiB;IACrD,MAAM,MAAM,GAAY,EAAE,CAAA;IAC1B,IAAI,GAAG,GAAG,CAAC,CAAA;IAEX,OAAO,GAAG,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC;QACxB,iCAAiC;QACjC,IAAI,GAAG,CAAC,GAAG,CAAC,KAAK,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC;YAC1C,GAAG,EAAE,CAAA;YACL,SAAQ;QACV,CAAC;QAED,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,CAAC,CAAA;QAC3C,IAAI,OAAO,EAAE,CAAC;YACZ,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAA;YACxE,GAAG,IAAI,OAAO,CAAC,KAAK,CAAC,MAAM,CAAA;YAC3B,SAAQ;QACV,CAAC;QAED,6DAA6D;QAC7D,MAAM,KAAK,GAAG,GAAG,CAAA;QACjB,OACE,GAAG,GAAG,GAAG,CAAC,MAAM;YAChB,GAAG,CAAC,GAAG,CAAC,KAAK,GAAG;YAChB,GAAG,CAAC,GAAG,CAAC,KAAK,IAAI;YACjB,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,CAAC,EAC5B,CAAC;YACD,GAAG,EAAE,CAAA;QACP,CAAC;QACD,IAAI,GAAG,GAAG,KAAK,EAAE,CAAC;YAChB,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAA;QAC9E,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAA;AACf,CAAC;AAED,SAAS,UAAU,CACjB,GAAW,EACX,GAAW,EACX,KAAiB;IAEjB,yEAAyE;IACzE,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;QACjC,IAAI,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,CAAC;YACrC,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAA;QACjD,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC"}

package/dist/graph/nav/parse/predicate.d.ts

@@ -0,0 +1,21 @@
+import type { Predicate } from '../ast/predicate/types';
+import type { TokenStream } from './stream';
+/**
+ * Parse a predicate expression from a token stream.
+ * Expects the stream to be positioned AFTER the opening '(' — i.e., the caller
+ * has already consumed PAREN_OPEN. Reads until the matching PAREN_CLOSE.
+ *
+ * Syntax:
+ *   property=value                          edge property (default scope)
+ *   node.property=value                     node property (explicit scope)
+ *   pred & pred                             AND
+ *   pred | pred                             OR
+ *   !pred  or  !(pred)                      NOT
+ *   (pred)                                  grouping
+ */
+export declare function parsePredicate(stream: TokenStream): Predicate;
+export declare class PredicateParseError extends Error {
+    readonly position: number;
+    constructor(message: string, position: number);
+}
+//# sourceMappingURL=predicate.d.ts.map

package/dist/graph/nav/parse/predicate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate.d.ts","sourceRoot":"","sources":["../../../../graph/nav/parse/predicate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,wBAAwB,CAAA;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAE3C;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,CAG7D;AAyFD,qBAAa,mBAAoB,SAAQ,KAAK;IAG1C,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAF3B,YACE,OAAO,EAAE,MAAM,EACN,QAAQ,EAAE,MAAM,EAI1B;CACF"}