@astrale-os/kernel-core 0.4.1

package/dist/graph/nav/scheme/slug.js

@@ -0,0 +1,86 @@
+/**
+ * Slug-array convergence point shared by both backward walkers.
+ *
+ * The in-memory walker (`./walk`) and the cypher walker
+ * (`kernel/adapters/graph/path/resolver/cypher.ts`) both produce a flat
+ * slug array per `PathType` — single-hop slugs leaf-to-anchor first,
+ * then recursive-hop slugs leaf-to-root. They diverge in *how* they
+ * harvest those slugs (interpreter vs. compiler) and converge here at
+ * `reconstructSteps`, which lifts the slug array back into the IR
+ * `Step[]` the rest of the system consumes.
+ *
+ * `traversalFromHop` is the leaf primitive — wrapped here so adding a
+ * new predicate scope or a new edge-property convention updates one
+ * site instead of two.
+ */
+import { SLUG_PROPERTY } from '../ast/slug';
+import { INBOUND, OUTBOUND } from '../ast/step';
+/**
+ * Build the IR `Traversal` step that consumes one hop on a slug match.
+ * Single source of truth for the `slug = <value>` edge predicate;
+ * adding a new predicate scope or property updates here.
+ */
+export function traversalFromHop(hop, slug) {
+    const dir = hop.direction === 'inbound' ? INBOUND : OUTBOUND;
+    return {
+        kind: 'traversal',
+        edgeClass: hop.edge,
+        ...dir,
+        predicate: {
+            kind: 'property',
+            scope: 'edge',
+            property: SLUG_PROPERTY,
+            op: '=',
+            value: slug,
+        },
+    };
+}
+/**
+ * Lift a flat slug array into the `Step[]` the PathType's segment chain
+ * would have parsed in the forward direction.
+ *
+ * Slug layout convention (shared by both backends):
+ *   - single-hop slugs first, leaf-to-anchor (one slug per single segment,
+ *     reverse declaration order);
+ *   - then recursive-hop slugs, leaf-to-root (one slug per traversal in the
+ *     bound recursion).
+ *
+ * Returns an empty array when `slugs` is empty. Callers that need to
+ * distinguish "no walk produced" from "walk produced anchor-only" do
+ * that upstream — this function trusts its inputs.
+ */
+export function reconstructSteps(type, slugs) {
+    const linearCount = countSingleHops(type);
+    const linearLeafToAnchor = slugs.slice(0, linearCount);
+    const treeLeafToRoot = slugs.slice(linearCount);
+    // Reverse linear slugs so index N maps to the Nth single-hop segment
+    // in declaration order (outer-anchor first).
+    const linearAnchorToLeaf = [...linearLeafToAnchor].reverse();
+    // Reverse tree slugs to root-to-leaf — the order has_parent
+    // traversals are emitted in the Step IR.
+    const treeRootToLeaf = [...treeLeafToRoot].reverse();
+    const steps = [];
+    let linearIdx = 0;
+    for (const seg of type.segments) {
+        if (seg.kind === 'recursive') {
+            steps.push(seg.anchor);
+            for (const slug of treeRootToLeaf)
+                steps.push(traversalFromHop(seg.hop, slug));
+        }
+        else {
+            const slug = linearAnchorToLeaf[linearIdx];
+            linearIdx++;
+            if (slug !== undefined)
+                steps.push(traversalFromHop(seg.hop, slug));
+        }
+    }
+    return steps;
+}
+function countSingleHops(type) {
+    let n = 0;
+    for (const seg of type.segments)
+        if (seg.kind === 'single')
+            n++;
+    return n;
+}
+//# sourceMappingURL=slug.js.map

package/dist/graph/nav/scheme/slug.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slug.js","sourceRoot":"","sources":["../../../../graph/nav/scheme/slug.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAE/C;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,GAAQ,EAAE,IAAY;IACrD,MAAM,GAAG,GAAG,GAAG,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAA;IAC5D,OAAO;QACL,IAAI,EAAE,WAAW;QACjB,SAAS,EAAE,GAAG,CAAC,IAAI;QACnB,GAAG,GAAG;QACN,SAAS,EAAE;YACT,IAAI,EAAE,UAAU;YAChB,KAAK,EAAE,MAAM;YACb,QAAQ,EAAE,aAAa;YACvB,EAAE,EAAE,GAAG;YACP,KAAK,EAAE,IAAI;SACZ;KACF,CAAA;AACH,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAc,EAAE,KAAwB;IACvE,MAAM,WAAW,GAAG,eAAe,CAAC,IAAI,CAAC,CAAA;IACzC,MAAM,kBAAkB,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,WAAW,CAAC,CAAA;IACtD,MAAM,cAAc,GAAG,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,CAAA;IAE/C,qEAAqE;IACrE,6CAA6C;IAC7C,MAAM,kBAAkB,GAAG,CAAC,GAAG,kBAAkB,CAAC,CAAC,OAAO,EAAE,CAAA;IAC5D,4DAA4D;IAC5D,yCAAyC;IACzC,MAAM,cAAc,GAAG,CAAC,GAAG,cAAc,CAAC,CAAC,OAAO,EAAE,CAAA;IAEpD,MAAM,KAAK,GAAW,EAAE,CAAA;IACxB,IAAI,SAAS,GAAG,CAAC,CAAA;IACjB,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;QAChC,IAAI,GAAG,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;YAC7B,KAAK,CAAC,IAAI,CAAE,GAAoB,CAAC,MAAM,CAAC,CAAA;YACxC,KAAK,MAAM,IAAI,IAAI,cAAc;gBAAE,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAA;QAChF,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAA;YAC1C,SAAS,EAAE,CAAA;YACX,IAAI,IAAI,KAAK,SAAS;gBAAE,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAE,GAAiB,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAA;QACpF,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED,SAAS,eAAe,CAAC,IAAc;IACrC,IAAI,CAAC,GAAG,CAAC,CAAA;IACT,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,QAAQ;QAAE,IAAI,GAAG,CAAC,IAAI,KAAK,QAAQ;YAAE,CAAC,EAAE,CAAA;IAC/D,OAAO,CAAC,CAAA;AACV,CAAC"}

package/dist/graph/nav/scheme/span.d.ts

@@ -0,0 +1,17 @@
+import type { Step } from '../ast/step';
+import type { SchemeSegment } from './segment';
+/**
+ * Forward shape: how many leading steps in `steps` (starting at
+ * `offset`) does this segment claim?
+ *
+ * `kind: 'single'` — match exactly one Traversal whose edge + IR
+ * direction matches the hop. Returns 1, or 0 when the head doesn't
+ * match (segment doesn't apply).
+ *
+ * `kind: 'recursive'` — match a leading Anchor that equals the
+ * segment's bound anchor, then any number of consecutive Traversals
+ * matching the hop. Returns the total claimed (≥ 1, since the anchor
+ * is always present).
+ */
+export declare function span(segment: SchemeSegment, steps: readonly Step[], offset: number): number;
+//# sourceMappingURL=span.d.ts.map

package/dist/graph/nav/scheme/span.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span.d.ts","sourceRoot":"","sources":["../../../../graph/nav/scheme/span.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,KAAK,EAAqB,aAAa,EAAE,MAAM,WAAW,CAAA;AAIjE;;;;;;;;;;;;GAYG;AACH,wBAAgB,IAAI,CAAC,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,SAAS,IAAI,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAK3F"}

package/dist/graph/nav/scheme/span.js

@@ -0,0 +1,41 @@
+import { INBOUND, OUTBOUND } from '../ast/step';
+/**
+ * Forward shape: how many leading steps in `steps` (starting at
+ * `offset`) does this segment claim?
+ *
+ * `kind: 'single'` — match exactly one Traversal whose edge + IR
+ * direction matches the hop. Returns 1, or 0 when the head doesn't
+ * match (segment doesn't apply).
+ *
+ * `kind: 'recursive'` — match a leading Anchor that equals the
+ * segment's bound anchor, then any number of consecutive Traversals
+ * matching the hop. Returns the total claimed (≥ 1, since the anchor
+ * is always present).
+ */
+export function span(segment, steps, offset) {
+    if (segment.kind === 'single') {
+        return matchesHop(steps[offset], segment.hop) ? 1 : 0;
+    }
+    return spanRecursive(segment, steps, offset);
+}
+function spanRecursive(segment, steps, offset) {
+    const head = steps[offset];
+    if (!head || head.kind !== 'anchor')
+        return 0;
+    if (head.id !== segment.anchor.id)
+        return 0;
+    let n = 1;
+    while (offset + n < steps.length && matchesHop(steps[offset + n], segment.hop)) {
+        n++;
+    }
+    return n;
+}
+function matchesHop(step, hop) {
+    if (!step || step.kind !== 'traversal')
+        return false;
+    if (step.edgeClass !== hop.edge)
+        return false;
+    const dir = hop.direction === 'inbound' ? INBOUND : OUTBOUND;
+    return step.from === dir.from && step.to === dir.to;
+}
+//# sourceMappingURL=span.js.map

package/dist/graph/nav/scheme/span.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"span.js","sourceRoot":"","sources":["../../../../graph/nav/scheme/span.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAE/C;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,IAAI,CAAC,OAAsB,EAAE,KAAsB,EAAE,MAAc;IACjF,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,UAAU,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IACvD,CAAC;IACD,OAAO,aAAa,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,CAAA;AAC9C,CAAC;AAED,SAAS,aAAa,CAAC,OAAqB,EAAE,KAAsB,EAAE,MAAc;IAClF,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,CAAA;IAC1B,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ;QAAE,OAAO,CAAC,CAAA;IAC7C,IAAI,IAAI,CAAC,EAAE,KAAK,OAAO,CAAC,MAAM,CAAC,EAAE;QAAE,OAAO,CAAC,CAAA;IAC3C,IAAI,CAAC,GAAG,CAAC,CAAA;IACT,OAAO,MAAM,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,IAAI,UAAU,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QAC/E,CAAC,EAAE,CAAA;IACL,CAAC;IACD,OAAO,CAAC,CAAA;AACV,CAAC;AAED,SAAS,UAAU,CAAC,IAAsB,EAAE,GAAQ;IAClD,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW;QAAE,OAAO,KAAK,CAAA;IACpD,IAAI,IAAI,CAAC,SAAS,KAAK,GAAG,CAAC,IAAI;QAAE,OAAO,KAAK,CAAA;IAC7C,MAAM,GAAG,GAAG,GAAG,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAA;IAC5D,OAAO,IAAI,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,EAAE,KAAK,GAAG,CAAC,EAAE,CAAA;AACrD,CAAC"}

package/dist/graph/nav/scheme/walk.d.ts

@@ -0,0 +1,20 @@
+import type { GraphView } from '#graph';
+import type { Path } from '#graph/nav/path';
+import type { Node } from '#graph/node/node';
+import type { SchemeSegment } from './segment';
+/**
+ * Per-segment harvest result — the flat slug array both backward
+ * walkers (in-memory + cypher) converge on (see `./slug`).
+ *
+ * `predecessor` is where the next outer segment picks up. Usually a
+ * Node; may be a Path when a single-hop's edge target isn't
+ * materialized as a graph node (e.g. the mount-parent of a
+ * non-root-mounted Domain) — the next outer segment must be recursive
+ * to absorb it.
+ */
+export interface SegmentWalkResult {
+    readonly slugs: readonly string[];
+    readonly predecessor: Node | Path | null;
+}
+export declare function walk(segment: SchemeSegment, target: Node | Path, graph: GraphView): SegmentWalkResult;
+//# sourceMappingURL=walk.d.ts.map

package/dist/graph/nav/scheme/walk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"walk.d.ts","sourceRoot":"","sources":["../../../../graph/nav/scheme/walk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAEvC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAI5C,OAAO,KAAK,EAAgB,aAAa,EAAa,MAAM,WAAW,CAAA;AAIvE;;;;;;;;;GASG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;IACjC,QAAQ,CAAC,WAAW,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;CACzC;AAED,wBAAgB,IAAI,CAClB,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,IAAI,GAAG,IAAI,EACnB,KAAK,EAAE,SAAS,GACf,iBAAiB,CAWnB"}

package/dist/graph/nav/scheme/walk.js

@@ -0,0 +1,75 @@
+import { AbsolutePath } from '#graph/tree/path/absolute';
+import { IdentifyError } from '../path/errors';
+export function walk(segment, target, graph) {
+    if (segment.kind === 'single') {
+        if (!isNode(target)) {
+            throw new IdentifyError(`${segment.name}: cannot walk single-hop from path "${target.raw}"`, 'broken-target');
+        }
+        return walkSingle(segment, target, graph);
+    }
+    return walkRecursive(segment, target, graph);
+}
+function walkSingle(segment, target, graph) {
+    const edges = graph.edgesOutgoing(target.id, segment.hop.edge);
+    if (edges.length === 0) {
+        throw new IdentifyError(`${segment.name}: node ${target.id} has no outgoing ${segment.hop.edge} edge`, 'orphan');
+    }
+    if (edges.length > 1) {
+        throw new IdentifyError(`${segment.name}: node ${target.id} has ${edges.length} outgoing ${segment.hop.edge} edges (expected 1)`, 'cardinality-violation');
+    }
+    const edge = edges[0];
+    const slug = readSlug(edge);
+    if (slug === null) {
+        throw new IdentifyError(`${segment.name}: outgoing ${segment.hop.edge} edge from ${target.id} has no slug`, 'missing-slug');
+    }
+    // Edge target may not resolve to a node (e.g. a Domain's
+    // `installed_in` pointing at a virtual mount-parent like `/space`);
+    // hand the Path to the outer recursive segment instead of failing.
+    const predecessor = graph.edgeTarget(edge) ?? edge.target;
+    return { slugs: [slug], predecessor };
+}
+function walkRecursive(segment, target, graph) {
+    // Path target: the slugs are already in `path.slugs` — no graph
+    // walk needed. Only absolute paths map onto a recursive scheme.
+    if (!isNode(target)) {
+        if (target.raw === segment.terminus)
+            return { slugs: [], predecessor: null };
+        if (!(target instanceof AbsolutePath)) {
+            throw new IdentifyError(`${segment.name}: cannot derive slugs from non-absolute path "${target.raw}"`, 'broken-target');
+        }
+        // path.slugs is root-to-leaf; emit leaf-to-root.
+        return { slugs: [...target.slugs].reverse(), predecessor: null };
+    }
+    const slugs = [];
+    let current = target;
+    while (current.path.raw !== segment.terminus) {
+        const edges = graph.edgesOutgoing(current.id, segment.hop.edge);
+        if (edges.length === 0) {
+            throw new IdentifyError(`${segment.name}: node ${current.id} has no outgoing ${segment.hop.edge} edge and path '${current.path.raw}' !== terminus '${segment.terminus}'`, 'orphan');
+        }
+        if (edges.length > 1) {
+            throw new IdentifyError(`${segment.name}: node ${current.id} has ${edges.length} outgoing ${segment.hop.edge} edges (expected at most 1)`, 'cardinality-violation');
+        }
+        const edge = edges[0];
+        const slug = readSlug(edge);
+        if (slug === null) {
+            throw new IdentifyError(`${segment.name}: outgoing ${segment.hop.edge} edge from ${current.id} has no slug`, 'missing-slug');
+        }
+        slugs.push(slug);
+        const next = graph.edgeTarget(edge);
+        if (next === null) {
+            throw new IdentifyError(`${segment.name}: outgoing ${segment.hop.edge} edge from ${current.id} points at unresolvable target ${edge.target.raw}`, 'broken-target');
+        }
+        current = next;
+    }
+    return { slugs, predecessor: null };
+}
+function isNode(x) {
+    return !('steps' in x);
+}
+function readSlug(edge) {
+    if (typeof edge.slug !== 'string' || edge.slug.length === 0)
+        return null;
+    return edge.slug;
+}
+//# sourceMappingURL=walk.js.map

package/dist/graph/nav/scheme/walk.js.map

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

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

@@ -0,0 +1,4 @@
+import type { Predicate } from '../ast/predicate/types';
+/** Serialize a predicate back to syntax form. */
+export declare function serializePredicate(pred: Predicate): string;
+//# sourceMappingURL=predicate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"predicate.d.ts","sourceRoot":"","sources":["../../../../graph/nav/serialize/predicate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAEvD,iDAAiD;AACjD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAa1D"}

package/dist/graph/nav/serialize/predicate.js

@@ -0,0 +1,24 @@
+/** Serialize a predicate back to syntax form. */
+export function serializePredicate(pred) {
+    switch (pred.kind) {
+        case 'property': {
+            const prefix = pred.scope === 'node' ? 'node.' : '';
+            return `${prefix}${pred.property}${pred.op}${pred.value}`;
+        }
+        case 'and':
+            return pred.operands.map((p) => wrapIfCompound(p, 'or')).join(' & ');
+        case 'or':
+            return pred.operands.map((p) => wrapIfCompound(p, 'and')).join(' | ');
+        case 'not':
+            return `!${wrapIfCompound(pred.operand, 'or', 'and')}`;
+    }
+}
+/** Wrap in parens if the inner predicate has lower or equal precedence to avoid ambiguity. */
+function wrapIfCompound(pred, ...wrapKinds) {
+    const s = serializePredicate(pred);
+    if (wrapKinds.includes(pred.kind)) {
+        return `(${s})`;
+    }
+    return s;
+}
+//# sourceMappingURL=predicate.js.map

package/dist/graph/nav/serialize/predicate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate.js","sourceRoot":"","sources":["../../../../graph/nav/serialize/predicate.ts"],"names":[],"mappings":"AAEA,iDAAiD;AACjD,MAAM,UAAU,kBAAkB,CAAC,IAAe;IAChD,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,UAAU,EAAE,CAAC;YAChB,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,KAAK,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAA;YACnD,OAAO,GAAG,MAAM,GAAG,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,CAAA;QAC3D,CAAC;QACD,KAAK,KAAK;YACR,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,cAAc,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QACtE,KAAK,IAAI;YACP,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,cAAc,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QACvE,KAAK,KAAK;YACR,OAAO,IAAI,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,CAAA;IAC1D,CAAC;AACH,CAAC;AAED,8FAA8F;AAC9F,SAAS,cAAc,CAAC,IAAe,EAAE,GAAG,SAAmB;IAC7D,MAAM,CAAC,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAA;IAClC,IAAI,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QAClC,OAAO,IAAI,CAAC,GAAG,CAAA;IACjB,CAAC;IACD,OAAO,CAAC,CAAA;AACV,CAAC"}

package/dist/graph/nav/serialize/steps.d.ts

@@ -0,0 +1,30 @@
+import type { Step } from '../ast/step';
+/**
+ * Serialize a single Step to its canonical raw form. Tries registered
+ * grammar extensions first (last-registered-first); falls through to
+ * the minimal core form when no extension claims the step.
+ *
+ * `prev` is the surrounding step's predecessor (or `null` when the
+ * step is at the head of the sequence) — extensions that emit joint
+ * sugar across adjacent steps (e.g. instance-method's `::<method>`)
+ * disambiguate via it. Standalone callers may pass `null`.
+ */
+export declare function serializeStep(step: Step, prev?: Step | null): string;
+/**
+ * Serialize a Step[] to its canonical raw form, routing each step
+ * through {@link serializeStep} with the previous step threaded as
+ * context.
+ *
+ * Single source of truth — used by both {@link buildPath} and the
+ * Graph's {@link PathIndex} to keep alias raws byte-equivalent across
+ * the lookup paths.
+ */
+export declare function serializeSteps(steps: readonly Step[]): string;
+/**
+ * Minimal direction- and slug-aware step serializer for steps that no
+ * grammar extension claims. Anchors emit `@<id>`. Traversals emit
+ * `<~<edgeClass>` (INBOUND) or `~<edgeClass>` (OUTBOUND), with a
+ * trailing `(<slug>)` when the predicate is an edge-scoped slug match.
+ */
+export declare function serializeStepCore(step: Step): string;
+//# sourceMappingURL=steps.d.ts.map

package/dist/graph/nav/serialize/steps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"steps.d.ts","sourceRoot":"","sources":["../../../../graph/nav/serialize/steps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAKvC;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,GAAE,IAAI,GAAG,IAAW,GAAG,MAAM,CAG1E;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,MAAM,CAQ7D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAYpD"}

package/dist/graph/nav/serialize/steps.js

@@ -0,0 +1,53 @@
+import { SLUG_PROPERTY } from '../ast/slug';
+import { GrammarRegistry } from '../grammar/registry';
+/**
+ * Serialize a single Step to its canonical raw form. Tries registered
+ * grammar extensions first (last-registered-first); falls through to
+ * the minimal core form when no extension claims the step.
+ *
+ * `prev` is the surrounding step's predecessor (or `null` when the
+ * step is at the head of the sequence) — extensions that emit joint
+ * sugar across adjacent steps (e.g. instance-method's `::<method>`)
+ * disambiguate via it. Standalone callers may pass `null`.
+ */
+export function serializeStep(step, prev = null) {
+    const piece = GrammarRegistry.serializeStep(step, prev);
+    return piece ?? serializeStepCore(step);
+}
+/**
+ * Serialize a Step[] to its canonical raw form, routing each step
+ * through {@link serializeStep} with the previous step threaded as
+ * context.
+ *
+ * Single source of truth — used by both {@link buildPath} and the
+ * Graph's {@link PathIndex} to keep alias raws byte-equivalent across
+ * the lookup paths.
+ */
+export function serializeSteps(steps) {
+    let out = '';
+    let prev = null;
+    for (const s of steps) {
+        out += serializeStep(s, prev);
+        prev = s;
+    }
+    return out || '/';
+}
+/**
+ * Minimal direction- and slug-aware step serializer for steps that no
+ * grammar extension claims. Anchors emit `@<id>`. Traversals emit
+ * `<~<edgeClass>` (INBOUND) or `~<edgeClass>` (OUTBOUND), with a
+ * trailing `(<slug>)` when the predicate is an edge-scoped slug match.
+ */
+export function serializeStepCore(step) {
+    if (step.kind === 'anchor')
+        return `@${step.id}`;
+    const dir = step.from === 'target' && step.to === 'source' ? '<~' : '~';
+    let s = `${dir}${step.edgeClass}`;
+    if (step.predicate?.kind === 'property' &&
+        step.predicate.scope === 'edge' &&
+        step.predicate.property === SLUG_PROPERTY) {
+        s += `(${step.predicate.value})`;
+    }
+    return s;
+}
+//# sourceMappingURL=steps.js.map

package/dist/graph/nav/serialize/steps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"steps.js","sourceRoot":"","sources":["../../../../graph/nav/serialize/steps.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAErD;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa,CAAC,IAAU,EAAE,IAAI,GAAgB,IAAI;IAChE,MAAM,KAAK,GAAG,eAAe,CAAC,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;IACvD,OAAO,KAAK,IAAI,iBAAiB,CAAC,IAAI,CAAC,CAAA;AACzC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAAC,KAAsB;IACnD,IAAI,GAAG,GAAG,EAAE,CAAA;IACZ,IAAI,IAAI,GAAgB,IAAI,CAAA;IAC5B,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;QACtB,GAAG,IAAI,aAAa,CAAC,CAAC,EAAE,IAAI,CAAC,CAAA;QAC7B,IAAI,GAAG,CAAC,CAAA;IACV,CAAC;IACD,OAAO,GAAG,IAAI,GAAG,CAAA;AACnB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAU;IAC1C,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ;QAAE,OAAO,IAAI,IAAI,CAAC,EAAE,EAAE,CAAA;IAChD,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,KAAK,QAAQ,IAAI,IAAI,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAA;IACvE,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC,SAAS,EAAE,CAAA;IACjC,IACE,IAAI,CAAC,SAAS,EAAE,IAAI,KAAK,UAAU;QACnC,IAAI,CAAC,SAAS,CAAC,KAAK,KAAK,MAAM;QAC/B,IAAI,CAAC,SAAS,CAAC,QAAQ,KAAK,aAAa,EACzC,CAAC;QACD,CAAC,IAAI,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,GAAG,CAAA;IAClC,CAAC;IACD,OAAO,CAAC,CAAA;AACV,CAAC"}

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

@@ -0,0 +1,2 @@
+export type { NodeSpec, Node } from './node';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../graph/node/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA"}

package/dist/graph/node/index.js

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

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

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

package/dist/graph/node/node.d.ts

@@ -0,0 +1,41 @@
+import type { ClassPath } from '#domain';
+import type { Properties } from '#graph/props';
+import type { AbsolutePath } from '#graph/tree';
+import type { NodeId } from '#ids';
+/**
+ * What you write (spec/draft) — the base node type.
+ *
+ * Paths in a Graph are always absolute. Relative addressing is a Tree-level
+ * concept (a node's position within a Tree's mount frame); see `PortableNode`
+ * in `graph/tree/serialize.ts` for the Tree-portable form.
+ *
+ * Remote sync metadata (externalId, updatedAt, onConflict) lives as plain
+ * properties under domain-qualified keys — see `foldRemote` / `unfoldRemote`
+ * in `graph/sync/remote/`. The `props` bag is the single source of truth.
+ */
+export interface NodeSpec {
+    readonly class: ClassPath;
+    readonly path: AbsolutePath;
+    readonly props: Readonly<Properties>;
+}
+/**
+ * What you read (from DB) — fully identified and located.
+ *
+ * `Node` is structurally minimal: `id`, `class`, `path`, `props`. Typed
+ * "semantic" projections (DomainPath, ClassPath, …) are derivations
+ * resolved on demand via the {@link Graph}'s multi-key path index — not
+ * fields on the node itself.
+ */
+export interface Node extends NodeSpec {
+    readonly id: NodeId;
+    /**
+     * Raw graph DB labels (FalkorDB `labels()`), set by the Cypher adapter.
+     *
+     * NOT a stable client contract — a storage detail that leaked. Clients
+     * needing the class should read {@link Node.class} (a `ClassPath`); concrete
+     * class checks belong on `class`, interface membership needs a dedicated
+     * primitive. See `.todo/kernel-labels-adapter-leak.md` (migration in progress).
+     */
+    readonly __labels?: string[];
+}
+//# sourceMappingURL=node.d.ts.map

package/dist/graph/node/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../graph/node/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAElC;;;;;;;;;;GAUG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAA;CACrC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,IAAK,SAAQ,QAAQ;IACpC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB;;;;;;;OAOG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CAC7B"}

package/dist/graph/node/node.js

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

package/dist/graph/node/node.js.map

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

package/dist/graph/node/zod.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Zod schemas for `NodeSpec` / `Node` records.
+ *
+ * Accepts both typed callers (Path instances) and wire callers (string paths)
+ * via `classPathSchema` / `absolutePathSchema`, which auto-coerce strings into
+ * `ClassPath` / `AbsolutePath` instances on parse.
+ *
+ * The inferred output type is structurally identical to `NodeSpec` (write-side)
+ * plus optional read-side fields (`id`, `__labels`). Compose with `graphSchema`
+ * or extend per call site when narrower input constraints apply.
+ */
+import { z } from 'zod';
+/** Wire-accepting schema for a node record. */
+export declare const nodeSchema: z.ZodObject<{
+    class: z.ZodType<import("../../domain").ClassPath, string | import("../../domain").ClassPath, z.core.$ZodTypeInternals<import("../../domain").ClassPath, string | import("../../domain").ClassPath>>;
+    path: z.ZodType<import("../tree").AbsolutePath, string | import("../tree").AbsolutePath, z.core.$ZodTypeInternals<import("../tree").AbsolutePath, string | import("../tree").AbsolutePath>>;
+    props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    id: z.ZodOptional<z.ZodString>;
+    __labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+//# sourceMappingURL=zod.d.ts.map

package/dist/graph/node/zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.d.ts","sourceRoot":"","sources":["../../../graph/node/zod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,+CAA+C;AAC/C,eAAO,MAAM,UAAU;;;;;;iBAMrB,CAAA"}

package/dist/graph/node/zod.js

@@ -0,0 +1,23 @@
+/**
+ * Zod schemas for `NodeSpec` / `Node` records.
+ *
+ * Accepts both typed callers (Path instances) and wire callers (string paths)
+ * via `classPathSchema` / `absolutePathSchema`, which auto-coerce strings into
+ * `ClassPath` / `AbsolutePath` instances on parse.
+ *
+ * The inferred output type is structurally identical to `NodeSpec` (write-side)
+ * plus optional read-side fields (`id`, `__labels`). Compose with `graphSchema`
+ * or extend per call site when narrower input constraints apply.
+ */
+import { z } from 'zod';
+import { classPathSchema } from '#domain/addressing/paths/zod';
+import { absolutePathSchema } from '#graph/tree/zod';
+/** Wire-accepting schema for a node record. */
+export const nodeSchema = z.object({
+    class: classPathSchema(),
+    path: absolutePathSchema(),
+    props: z.record(z.string(), z.unknown()),
+    id: z.string().optional(),
+    __labels: z.array(z.string()).optional(),
+});
+//# sourceMappingURL=zod.js.map

package/dist/graph/node/zod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.js","sourceRoot":"","sources":["../../../graph/node/zod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAEpD,+CAA+C;AAC/C,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC;IACjC,KAAK,EAAE,eAAe,EAAE;IACxB,IAAI,EAAE,kBAAkB,EAAE;IAC1B,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;IACxC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACzB,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;CACzC,CAAC,CAAA"}

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

@@ -0,0 +1,2 @@
+export type { Properties } from './props';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../graph/props/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA"}

package/dist/graph/props/index.js

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

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

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

package/dist/graph/props/properties.d.ts

@@ -0,0 +1,3 @@
+/** Generic property bag for nodes and edges. */
+export type Properties = Record<string, unknown>;
+//# sourceMappingURL=properties.d.ts.map

package/dist/graph/props/properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"properties.d.ts","sourceRoot":"","sources":["../../../graph/props/properties.ts"],"names":[],"mappings":"AAAA,gDAAgD;AAChD,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA"}

package/dist/graph/props/properties.js

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

package/dist/graph/props/properties.js.map

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

package/dist/graph/props/props.d.ts

@@ -0,0 +1,3 @@
+/** Generic property bag for nodes and edges. */
+export type Properties = Record<string, unknown>;
+//# sourceMappingURL=props.d.ts.map

package/dist/graph/props/props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"props.d.ts","sourceRoot":"","sources":["../../../graph/props/props.ts"],"names":[],"mappings":"AAAA,gDAAgD;AAChD,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA"}

package/dist/graph/props/props.js

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

package/dist/graph/props/props.js.map

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

package/dist/graph/sync/apply/index.d.ts

@@ -0,0 +1,4 @@
+export { DEFAULT_INTEGRITY_CONSTRAINTS, type IntegrityConstraints } from './integrity';
+export type { PushResult, SyncResult } from './push-result';
+export type { ValidationError, ValidationWarning, PatchAdjustment, PatchValidationResult, } from './validation';
+//# sourceMappingURL=index.d.ts.map

package/dist/graph/sync/apply/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../graph/sync/apply/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,KAAK,oBAAoB,EAAE,MAAM,aAAa,CAAA;AACtF,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC3D,YAAY,EACV,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,qBAAqB,GACtB,MAAM,cAAc,CAAA"}

package/dist/graph/sync/apply/index.js

@@ -0,0 +1,2 @@
+export { DEFAULT_INTEGRITY_CONSTRAINTS } from './integrity';
+//# sourceMappingURL=index.js.map

package/dist/graph/sync/apply/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../graph/sync/apply/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAA6B,MAAM,aAAa,CAAA"}

package/dist/graph/sync/apply/integrity.d.ts

@@ -0,0 +1,11 @@
+import type { ClassPath } from '#domain';
+export interface IntegrityConstraints {
+    /** ClassPaths that must never be created, modified, or deleted through sync. */
+    forbiddenClasses: ClassPath[];
+    /** Interfaces whose implementors are forbidden (transitive check via DomainRegistry). */
+    forbiddenInterfaces: ClassPath[];
+    orphanPolicy: 'cascade' | 'error';
+    externalEdgePolicy: 'allow' | 'warn' | 'error';
+}
+export declare const DEFAULT_INTEGRITY_CONSTRAINTS: IntegrityConstraints;
+//# sourceMappingURL=integrity.d.ts.map

package/dist/graph/sync/apply/integrity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrity.d.ts","sourceRoot":"","sources":["../../../../graph/sync/apply/integrity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAExC,MAAM,WAAW,oBAAoB;IACnC,gFAAgF;IAChF,gBAAgB,EAAE,SAAS,EAAE,CAAA;IAC7B,yFAAyF;IACzF,mBAAmB,EAAE,SAAS,EAAE,CAAA;IAChC,YAAY,EAAE,SAAS,GAAG,OAAO,CAAA;IACjC,kBAAkB,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,CAAA;CAC/C;AAED,eAAO,MAAM,6BAA6B,EAAE,oBAK3C,CAAA"}

package/dist/graph/sync/apply/integrity.js

@@ -0,0 +1,7 @@
+export const DEFAULT_INTEGRITY_CONSTRAINTS = {
+    forbiddenClasses: [],
+    forbiddenInterfaces: [],
+    orphanPolicy: 'error',
+    externalEdgePolicy: 'warn',
+};
+//# sourceMappingURL=integrity.js.map

package/dist/graph/sync/apply/integrity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrity.js","sourceRoot":"","sources":["../../../../graph/sync/apply/integrity.ts"],"names":[],"mappings":"AAWA,MAAM,CAAC,MAAM,6BAA6B,GAAyB;IACjE,gBAAgB,EAAE,EAAE;IACpB,mBAAmB,EAAE,EAAE;IACvB,YAAY,EAAE,OAAO;IACrB,kBAAkB,EAAE,MAAM;CAC3B,CAAA"}