@astrale-os/kernel-core 0.4.1

package/dist/graph/graph/walker.js

@@ -0,0 +1,126 @@
+import { predicateMatches } from '#graph/nav';
+import { isRootAnchor } from '#graph/nav/path/step';
+import { reverseSteps, stepsEqual } from '#graph/nav/path/step/reverse';
+import { AmbiguousWalkError } from '../errors';
+import { EMPTY_EDGES } from './indexes/edges';
+const EMPTY_STEPS = Object.freeze([]);
+/**
+ * Walk `steps` from `start` against the in-memory graph, returning a
+ * tagged result:
+ *
+ * - `node` — every step consumed and the cursor landed on an in-graph
+ *   Node.
+ * - `escape` — the cursor reached a typed endpoint Path that
+ *   self-identifies the unconsumed residue (I7).
+ * - `miss` — a step had no matching edge, or escape verification
+ *   failed.
+ *
+ * Strictly non-recursive (I5 / T2): never re-enters the graph's
+ * `nodes.get` / `nodes.at`.
+ */
+export function walkSteps(steps, start, ctx) {
+    let current = start;
+    for (let i = 0; i < steps.length; i++) {
+        if (!isNode(current)) {
+            return matchEscape(current, steps.slice(i));
+        }
+        const next = traverseStep(current, steps[i], ctx);
+        if (next === null)
+            return { kind: 'miss' };
+        current = next;
+    }
+    return isNode(current) ? { kind: 'node', node: current } : matchEscape(current, EMPTY_STEPS);
+}
+/**
+ * Advance one step from a node. Returns the next Node (in-graph
+ * endpoint) or the endpoint Path (typed endpoint — next iteration
+ * decides escape or miss). Uses the raw index map directly; never
+ * calls `Graph.nodes.get` / `nodes.at` (I5 / T2).
+ */
+export function traverseStep(from, step, ctx) {
+    if (step.kind === 'anchor') {
+        // RootAnchor (target = __SYSTEM__) resolves to the graph's root
+        // node. Other id anchors look up the node by id.
+        if (isRootAnchor(step))
+            return ctx.root;
+        return ctx.nodeById.get(step.id) ?? null;
+    }
+    const edge = edgeIncident(from, step, ctx);
+    if (!edge)
+        return null;
+    const endpoint = step.to === 'source' ? edge.source : edge.target;
+    return ctx.nodeByPath.get(endpoint.raw) ?? endpoint;
+}
+/**
+ * The unique edge at `from` that satisfies `step`. Raises
+ * `AmbiguousWalkError` on multi-match (I6).
+ */
+export function edgeIncident(from, step, ctx) {
+    const candidates = ctx.edgesByEdgeClass.get(step.edgeClass) ?? EMPTY_EDGES;
+    let match = null;
+    let count = 0;
+    for (const e of candidates) {
+        if (!matchesStep(e, from, step, ctx))
+            continue;
+        count++;
+        if (count > 1)
+            throw new AmbiguousWalkError(step, from.path.raw, count);
+        match = e;
+    }
+    return match;
+}
+/**
+ * Every edge whose class + predicate satisfies `step`, regardless of
+ * role. Used by reverse-walk candidate enumeration in the resolver.
+ */
+export function edgesByStep(step, ctx) {
+    const candidates = ctx.edgesByEdgeClass.get(step.edgeClass) ?? EMPTY_EDGES;
+    const bucket = [];
+    for (const e of candidates) {
+        if (!predicateMatches(step.predicate, edgePred(e)))
+            continue;
+        bucket.push(e);
+    }
+    return bucket;
+}
+function matchesStep(edge, from, step, ctx) {
+    const fromEndpoint = step.from === 'source' ? edge.source : edge.target;
+    // Single-lane match via the multi-key {@link PathIndex}: any
+    // registered alias of `from` (its primary AbsolutePath plus every
+    // typed-form alias produced by registered PathTypes) resolves to
+    // the same Node. `Graph.from` always wires a `pathIndex`; the null
+    // branch is a defensive fallback that should never fire in
+    // production paths.
+    if (ctx.pathIndex) {
+        return (ctx.pathIndex.get(fromEndpoint.raw) === from &&
+            predicateMatches(step.predicate, edgePred(edge)));
+    }
+    return fromEndpoint.raw === from.path.raw && predicateMatches(step.predicate, edgePred(edge));
+}
+/**
+ * Project the edge into the minimal shape `predicateMatches` reads.
+ * The matcher is edge-scope only — it does not need endpoints.
+ */
+function edgePred(edge) {
+    return { slug: edge.slug, props: edge.props };
+}
+/**
+ * Decide whether a typed endpoint Path's `steps` (reversed) equal the
+ * remaining unconsumed steps of the walk. If so, the walker has found
+ * an `escape` — the typed endpoint self-identifies the residue (I7).
+ * Otherwise it's a `miss`.
+ */
+function matchEscape(endpoint, remaining) {
+    return stepsEqual(reverseSteps(endpoint.steps), remaining)
+        ? { kind: 'escape', endpoint }
+        : { kind: 'miss' };
+}
+/**
+ * Distinguish Node from Path at runtime. Nodes have `class`, `path`,
+ * `props`; Paths have `steps`. Negating `'steps' in x` narrows the
+ * union.
+ */
+export function isNode(x) {
+    return !('steps' in x);
+}
+//# sourceMappingURL=walker.js.map

package/dist/graph/graph/walker.js.map

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

package/dist/graph/graph/wire.d.ts

@@ -0,0 +1,34 @@
+import type { Path } from '#graph/nav/path';
+import type { NodeId } from '#ids';
+import type { Edge } from '../edge';
+import type { Node } from '../node';
+/**
+ * JSON-safe projection of a kernel `Node`. Collapses `class` and
+ * `path` to their raw strings; passes other fields through unchanged.
+ */
+export declare function nodeToWire(n: Node): Record<string, unknown>;
+/**
+ * JSON-safe projection of a kernel `Edge`. Collapses `class` /
+ * `source` / `target` to their raw strings; preserves `slug` only
+ * when present (omits the `slug` key entirely when undefined).
+ */
+export declare function edgeToWire(e: Edge): Record<string, unknown>;
+/**
+ * Wire shape for the `aliases` sidecar after `JSON.stringify` — a
+ * tuple array of `[nodeId, pathRaw]`. Symmetric with the in-process
+ * {@link GraphData.aliases} shape (`Array<[NodeId, Path]>`): the only
+ * difference is that Path leaves arrive as raw strings, since
+ * `Path.toJSON` collapses each Path to its `.raw` on serialize.
+ */
+export type AliasesWire = ReadonlyArray<readonly [NodeId, string]>;
+/**
+ * Rehydrate an alias wire payload into the typed
+ * `Array<[NodeId, Path]>` shape that `GraphData.aliases` expects.
+ * Each `pathRaw` is parsed through {@link parsePath}, which routes to
+ * the most-specific registered {@link PathType} (typed semantic forms)
+ * or falls back to the base `Path` — symmetric with how
+ * `normalizeNodeSpec` / `normalizeEdgeSpec` rehydrate Path-shaped
+ * fields elsewhere.
+ */
+export declare function aliasesFromWire(wire: AliasesWire): Array<readonly [NodeId, Path]>;
+//# sourceMappingURL=wire.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wire.d.ts","sourceRoot":"","sources":["../../../graph/graph/wire.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAIlC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AACnC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAEnC;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAG3D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAS3D;AAED;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;AAElE;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,WAAW,GAAG,KAAK,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAEjF"}

package/dist/graph/graph/wire.js

@@ -0,0 +1,37 @@
+import { parsePath } from '#graph/nav/path';
+/**
+ * JSON-safe projection of a kernel `Node`. Collapses `class` and
+ * `path` to their raw strings; passes other fields through unchanged.
+ */
+export function nodeToWire(n) {
+    const { class: cls, path, ...rest } = n;
+    return { ...rest, class: cls.raw, path: path.raw };
+}
+/**
+ * JSON-safe projection of a kernel `Edge`. Collapses `class` /
+ * `source` / `target` to their raw strings; preserves `slug` only
+ * when present (omits the `slug` key entirely when undefined).
+ */
+export function edgeToWire(e) {
+    const { class: cls, source, target, slug, ...rest } = e;
+    return {
+        ...rest,
+        class: cls.raw,
+        source: source.raw,
+        target: target.raw,
+        ...(slug !== undefined && { slug }),
+    };
+}
+/**
+ * Rehydrate an alias wire payload into the typed
+ * `Array<[NodeId, Path]>` shape that `GraphData.aliases` expects.
+ * Each `pathRaw` is parsed through {@link parsePath}, which routes to
+ * the most-specific registered {@link PathType} (typed semantic forms)
+ * or falls back to the base `Path` — symmetric with how
+ * `normalizeNodeSpec` / `normalizeEdgeSpec` rehydrate Path-shaped
+ * fields elsewhere.
+ */
+export function aliasesFromWire(wire) {
+    return wire.map(([id, raw]) => [id, parsePath(raw)]);
+}
+//# sourceMappingURL=wire.js.map

package/dist/graph/graph/wire.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.js","sourceRoot":"","sources":["../../../graph/graph/wire.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAK3C;;;GAGG;AACH,MAAM,UAAU,UAAU,CAAC,CAAO;IAChC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,GAAG,CAAmC,CAAA;IACzE,OAAO,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,CAAA;AACpD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,CAAO;IAChC,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,GAAG,CAAmC,CAAA;IACzF,OAAO;QACL,GAAG,IAAI;QACP,KAAK,EAAE,GAAG,CAAC,GAAG;QACd,MAAM,EAAE,MAAM,CAAC,GAAG;QAClB,MAAM,EAAE,MAAM,CAAC,GAAG;QAClB,GAAG,CAAC,IAAI,KAAK,SAAS,IAAI,EAAE,IAAI,EAAE,CAAC;KACpC,CAAA;AACH,CAAC;AAWD;;;;;;;;GAQG;AACH,MAAM,UAAU,eAAe,CAAC,IAAiB;IAC/C,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC,GAAG,CAAC,CAAU,CAAC,CAAA;AAC/D,CAAC"}

package/dist/graph/index.d.ts

@@ -0,0 +1,18 @@
+export type { Properties } from './props';
+export type { ConflictStrategy, RemoteSpec, ExternalId } from '#ids';
+export type { NodeSpec, Node } from './node';
+export type { EdgeSpec, Edge } from './edge';
+export { toEdgeKey } from './edge';
+export type { EdgeIdentity, EdgeKey } from './edge';
+export { Graph, isVirtualRoot } from './graph';
+export type { WalkResult } from './graph';
+export type { GraphData } from './types';
+export { aliasesFromWire } from './graph';
+export type { AliasesWire, WireGraph } from './graph';
+export type { GraphView } from './graph';
+export { BuildTimeView } from './graph';
+export { Patch, Minter } from './sync/patch';
+export type { NodeCreate, NodeUpdate, NodeDelete, EdgeCreate, EdgeUpdate, EdgeDelete, EdgeMatcher, PatchData, } from './sync/patch';
+export { GraphValidationError, AmbiguousWalkError, RootProtectedError, NodeNotEmptyError, } from './errors';
+export type { GraphViolation } from './errors';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../graph/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGzC,YAAY,EAAE,gBAAgB,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,MAAM,CAAA;AAGpE,YAAY,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAG5C,YAAY,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAClC,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAGnD,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAC9C,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACzC,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAGxC,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACzC,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAGrD,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAGvC,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAC5C,YAAY,EACV,UAAU,EACV,UAAU,EACV,UAAU,EACV,UAAU,EACV,UAAU,EACV,UAAU,EACV,WAAW,EACX,SAAS,GACV,MAAM,cAAc,CAAA;AAGrB,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,UAAU,CAAA;AACjB,YAAY,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA"}

package/dist/graph/index.js

@@ -0,0 +1,14 @@
+export { toEdgeKey } from './edge';
+// ─── Graph (the substrate primitive) ────────────────────────
+export { Graph, isVirtualRoot } from './graph';
+// ─── Wire boundary parser ───────────────────────────────────
+export { aliasesFromWire } from './graph';
+export { BuildTimeView } from './graph';
+// ─── Patch (SPEC §4.7 authoring record + reconcile-output, unified) ──
+export { Patch, Minter } from './sync/patch';
+// ─── Errors ─────────────────────────────────────────────────
+export { GraphValidationError, AmbiguousWalkError, RootProtectedError, NodeNotEmptyError, } from './errors';
+// Boundary schemas live at `@astrale-os/kernel-core/graph-parse` — importing
+// them from `#graph` would pull zod + domain-path schemas into every caller's
+// module graph and create a circular-import cycle with AbsolutePath init.
+//# sourceMappingURL=index.js.map

package/dist/graph/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../graph/index.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAGlC,+DAA+D;AAC/D,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAI9C,+DAA+D;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAKzC,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAEvC,wEAAwE;AACxE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAY5C,+DAA+D;AAC/D,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,UAAU,CAAA;AAGjB,6EAA6E;AAC7E,8EAA8E;AAC9E,0EAA0E"}

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

@@ -0,0 +1,3 @@
+export type { Predicate, PredicateOp, PredicateScope, PropertyPredicate, AndPredicate, OrPredicate, NotPredicate, } from './types';
+export { predicateMatches, predicateEqual } from './operations';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../graph/nav/ast/predicate/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,SAAS,EACT,WAAW,EACX,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,WAAW,EACX,YAAY,GACb,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA"}

package/dist/graph/nav/ast/predicate/index.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../graph/nav/ast/predicate/index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA"}

package/dist/graph/nav/ast/predicate/operations.d.ts

@@ -0,0 +1,27 @@
+import type { Predicate } from './types';
+/**
+ * Evaluate a step predicate against an edge.
+ *
+ * Edge-scope only. `scope: 'edge'` on `property: 'slug'` reads the
+ * edge's first-class slug; other edge-scope properties read from
+ * `edge.props`.
+ *
+ * `scope: 'node'` predicates are AST-supported (parser produces them,
+ * serializer emits them — kept for forward compatibility with a future
+ * Query evaluator) but throw here: this matcher only sees the edge
+ * being filtered, not its endpoints. Callers that need node-scope
+ * evaluation must use a richer evaluator that has endpoint access.
+ */
+export declare function predicateMatches(predicate: Predicate | undefined, edge: {
+    readonly slug?: string | undefined;
+    readonly props: Readonly<Record<string, unknown>>;
+}): boolean;
+/**
+ * Structural equality on the predicate AST.
+ *
+ * Public (vs file-private) because `stepsEqual` lives in
+ * `ast/step/reverse.ts` — a separate file from the predicate AST —
+ * and needs cross-file access.
+ */
+export declare function predicateEqual(a: Predicate | undefined, b: Predicate | undefined): boolean;
+//# sourceMappingURL=operations.d.ts.map

package/dist/graph/nav/ast/predicate/operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../../../../graph/nav/ast/predicate/operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAIxC;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,SAAS,GAAG,SAAS,EAChC,IAAI,EAAE;IAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CAAE,GAC9F,OAAO,CAsBT;AAMD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,CAyB1F"}

package/dist/graph/nav/ast/predicate/operations.js

@@ -0,0 +1,75 @@
+import { SLUG_PROPERTY } from '../slug';
+/**
+ * Evaluate a step predicate against an edge.
+ *
+ * Edge-scope only. `scope: 'edge'` on `property: 'slug'` reads the
+ * edge's first-class slug; other edge-scope properties read from
+ * `edge.props`.
+ *
+ * `scope: 'node'` predicates are AST-supported (parser produces them,
+ * serializer emits them — kept for forward compatibility with a future
+ * Query evaluator) but throw here: this matcher only sees the edge
+ * being filtered, not its endpoints. Callers that need node-scope
+ * evaluation must use a richer evaluator that has endpoint access.
+ */
+export function predicateMatches(predicate, edge) {
+    if (predicate === undefined)
+        return true;
+    switch (predicate.kind) {
+        case 'property': {
+            if (predicate.scope !== 'edge') {
+                throw new Error(`predicateMatches: node-scope predicate ('${predicate.property}') is not evaluable by the edge matcher`);
+            }
+            const actual = predicate.property === SLUG_PROPERTY
+                ? (edge.slug ?? undefined)
+                : edge.props[predicate.property];
+            return compare(actual, predicate.op, predicate.value);
+        }
+        case 'and':
+            return predicate.operands.every((p) => predicateMatches(p, edge));
+        case 'or':
+            return predicate.operands.some((p) => predicateMatches(p, edge));
+        case 'not':
+            return !predicateMatches(predicate.operand, edge);
+    }
+}
+function compare(actual, op, expected) {
+    return op === '=' && actual === expected;
+}
+/**
+ * Structural equality on the predicate AST.
+ *
+ * Public (vs file-private) because `stepsEqual` lives in
+ * `ast/step/reverse.ts` — a separate file from the predicate AST —
+ * and needs cross-file access.
+ */
+export function predicateEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a === undefined || b === undefined)
+        return false;
+    if (a.kind !== b.kind)
+        return false;
+    switch (a.kind) {
+        case 'property': {
+            const bp = b;
+            return (a.scope === bp.scope && a.property === bp.property && a.op === bp.op && a.value === bp.value);
+        }
+        case 'and':
+        case 'or': {
+            const bp = b;
+            if (a.operands.length !== bp.operands.length)
+                return false;
+            for (let i = 0; i < a.operands.length; i++) {
+                if (!predicateEqual(a.operands[i], bp.operands[i]))
+                    return false;
+            }
+            return true;
+        }
+        case 'not': {
+            const bp = b;
+            return predicateEqual(a.operand, bp.operand);
+        }
+    }
+}
+//# sourceMappingURL=operations.js.map

package/dist/graph/nav/ast/predicate/operations.js.map

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

package/dist/graph/nav/ast/predicate/types.d.ts

@@ -0,0 +1,28 @@
+export type PredicateOp = '=';
+/** Whether the predicate targets the traversed edge or the target node. */
+export type PredicateScope = 'edge' | 'node';
+/** Leaf: compare a property to a literal value. */
+export interface PropertyPredicate {
+    readonly kind: 'property';
+    readonly scope: PredicateScope;
+    readonly property: string;
+    readonly op: PredicateOp;
+    readonly value: string;
+}
+/** Conjunction: all operands must match. */
+export interface AndPredicate {
+    readonly kind: 'and';
+    readonly operands: readonly Predicate[];
+}
+/** Disjunction: at least one operand must match. */
+export interface OrPredicate {
+    readonly kind: 'or';
+    readonly operands: readonly Predicate[];
+}
+/** Negation: must not match. */
+export interface NotPredicate {
+    readonly kind: 'not';
+    readonly operand: Predicate;
+}
+export type Predicate = PropertyPredicate | AndPredicate | OrPredicate | NotPredicate;
+//# sourceMappingURL=types.d.ts.map

package/dist/graph/nav/ast/predicate/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../graph/nav/ast/predicate/types.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,WAAW,GAAG,GAAG,CAAA;AAE7B,2EAA2E;AAC3E,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,MAAM,CAAA;AAE5C,mDAAmD;AACnD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAA;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB;AAED,4CAA4C;AAC5C,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,QAAQ,EAAE,SAAS,SAAS,EAAE,CAAA;CACxC;AAED,oDAAoD;AACpD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,QAAQ,EAAE,SAAS,SAAS,EAAE,CAAA;CACxC;AAED,gCAAgC;AAChC,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAA;CAC5B;AAED,MAAM,MAAM,SAAS,GAAG,iBAAiB,GAAG,YAAY,GAAG,WAAW,GAAG,YAAY,CAAA"}

package/dist/graph/nav/ast/predicate/types.js

@@ -0,0 +1,3 @@
+// ── Predicate Algebra ─────────────────────────────────────
+export {};
+//# sourceMappingURL=types.js.map

package/dist/graph/nav/ast/predicate/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../graph/nav/ast/predicate/types.ts"],"names":[],"mappings":"AAAA,6DAA6D"}

package/dist/graph/nav/ast/slug.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const SLUG_RE: RegExp;
+/**
+ * Well-known property key under which an edge's slug is stored.
+ *
+ * Single source of truth across the kernel. Predicate evaluation,
+ * scheme walks, and grammar extensions all reference this constant
+ * rather than the literal `'slug'`. The predicate evaluator special-
+ * cases this key to read `ctx.edge.slug` directly.
+ */
+export declare const SLUG_PROPERTY: 'slug';
+/** Branded slug — validated to match SLUG_RE. */
+export type Slug = string & {
+    readonly __slug: true;
+};
+/** Zod schema for a slug — validates format, length 1–255. */
+export declare const slugSchema: z.ZodPipe<z.ZodString, z.ZodTransform<Slug, string>>;
+//# sourceMappingURL=slug.d.ts.map

package/dist/graph/nav/ast/slug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slug.d.ts","sourceRoot":"","sources":["../../../../graph/nav/ast/slug.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,OAAO,QAAiD,CAAA;AAErE;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,EAAG,MAAe,CAAA;AAE5C,iDAAiD;AACjD,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAA;AAErD,8DAA8D;AAC9D,eAAO,MAAM,UAAU,sDAKO,CAAA"}

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

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export const SLUG_RE = /^[a-zA-Z0-9](?:[a-zA-Z0-9._-]*[a-zA-Z0-9])?$/;
+/**
+ * Well-known property key under which an edge's slug is stored.
+ *
+ * Single source of truth across the kernel. Predicate evaluation,
+ * scheme walks, and grammar extensions all reference this constant
+ * rather than the literal `'slug'`. The predicate evaluator special-
+ * cases this key to read `ctx.edge.slug` directly.
+ */
+export const SLUG_PROPERTY = 'slug';
+/** Zod schema for a slug — validates format, length 1–255. */
+export const slugSchema = z
+    .string()
+    .min(1)
+    .max(255)
+    .regex(SLUG_RE, 'Slug must start/end with alphanumeric and contain only [a-zA-Z0-9._-]')
+    .transform((s) => s);
+//# sourceMappingURL=slug.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slug.js","sourceRoot":"","sources":["../../../../graph/nav/ast/slug.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,MAAM,CAAC,MAAM,OAAO,GAAG,8CAA8C,CAAA;AAErE;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,MAAe,CAAA;AAK5C,8DAA8D;AAC9D,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC;KACxB,MAAM,EAAE;KACR,GAAG,CAAC,CAAC,CAAC;KACN,GAAG,CAAC,GAAG,CAAC;KACR,KAAK,CAAC,OAAO,EAAE,uEAAuE,CAAC;KACvF,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAS,CAAC,CAAA"}

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

@@ -0,0 +1,33 @@
+import type { NodeId } from '#ids';
+/**
+ * Anchor — a step that pins the walk to a specific node *without*
+ * traversing an edge. Two callsites use this:
+ *
+ *  - The implicit graph root, materialized by the absolute grammar
+ *    (`/`, `/foo`, `/:dom`, …) and by every typed scheme composed on
+ *    top of it (DomainPath, ClassPath, …). Carries the well-known
+ *    `__SYSTEM__` id — see {@link ROOT_ANCHOR}.
+ *
+ *  - A direct node reference (`@<id>` sugar). Used standalone by
+ *    {@link IdPath} and as the source prefix of an `@id::method`
+ *    instance-method invocation.
+ *
+ * Anchor presence at `steps[0]` is the discriminator that distinguishes
+ * absolute (anchored) paths from relative (un-anchored) paths in the
+ * Step IR. Relative paths have no leading anchor; absolute paths always
+ * do — either the root anchor or an id anchor.
+ */
+export interface Anchor {
+    readonly kind: 'anchor';
+    readonly id: NodeId;
+}
+/**
+ * Singleton root anchor — points at the well-known system root id.
+ * Stable identity for cheap reference equality at hot paths.
+ */
+export declare const ROOT_ANCHOR: Anchor;
+/** Build an id anchor pointing at `id`. */
+export declare function idAnchor(id: NodeId): Anchor;
+/** Whether this anchor refers to the implicit graph root. */
+export declare function isRootAnchor(step: Anchor): boolean;
+//# sourceMappingURL=anchor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"anchor.d.ts","sourceRoot":"","sources":["../../../../../graph/nav/ast/step/anchor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAIlC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CACpB;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,MAA0D,CAAA;AAEpF,2CAA2C;AAC3C,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAE3C;AAED,6DAA6D;AAC7D,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD"}

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

@@ -0,0 +1,15 @@
+import { __SYSTEM__ } from '#ids';
+/**
+ * Singleton root anchor — points at the well-known system root id.
+ * Stable identity for cheap reference equality at hot paths.
+ */
+export const ROOT_ANCHOR = Object.freeze({ kind: 'anchor', id: __SYSTEM__ });
+/** Build an id anchor pointing at `id`. */
+export function idAnchor(id) {
+    return { kind: 'anchor', id };
+}
+/** Whether this anchor refers to the implicit graph root. */
+export function isRootAnchor(step) {
+    return step.id === __SYSTEM__;
+}
+//# sourceMappingURL=anchor.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"anchor.js","sourceRoot":"","sources":["../../../../../graph/nav/ast/step/anchor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAA;AAyBjC;;;GAGG;AACH,MAAM,CAAC,MAAM,WAAW,GAAW,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC,CAAA;AAEpF,2CAA2C;AAC3C,MAAM,UAAU,QAAQ,CAAC,EAAU;IACjC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAA;AAC/B,CAAC;AAED,6DAA6D;AAC7D,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,OAAO,IAAI,CAAC,EAAE,KAAK,UAAU,CAAA;AAC/B,CAAC"}

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

@@ -0,0 +1,7 @@
+export { type Anchor, ROOT_ANCHOR, idAnchor, isRootAnchor } from './anchor';
+export { type Traversal, OUTBOUND, INBOUND } from './traversal';
+import type { Anchor } from './anchor';
+import type { Traversal } from './traversal';
+/** The complete step union for Path. Deterministic addressing: two kinds only. */
+export type Step = Anchor | Traversal;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../graph/nav/ast/step/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAC3E,OAAO,EAAE,KAAK,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAE/D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACtC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAE5C,kFAAkF;AAClF,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,SAAS,CAAA"}

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

@@ -0,0 +1,3 @@
+export { ROOT_ANCHOR, idAnchor, isRootAnchor } from './anchor';
+export { OUTBOUND, INBOUND } from './traversal';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../graph/nav/ast/step/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAC3E,OAAO,EAAkB,QAAQ,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA"}

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

@@ -0,0 +1,21 @@
+import type { Step } from './index';
+/**
+ * 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 declare function reverseStep(step: Step): Step;
+/**
+ * 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 declare function reverseSteps(steps: readonly Step[]): Step[];
+/**
+ * Deep structural equality on step sequences. Compares kind, edgeClass,
+ * from/to, anchor id, and predicate by structural shape.
+ */
+export declare function stepsEqual(a: readonly Step[], b: readonly Step[]): boolean;
+//# sourceMappingURL=reverse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reverse.d.ts","sourceRoot":"","sources":["../../../../../graph/nav/ast/step/reverse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAa,MAAM,SAAS,CAAA;AAI9C;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAS5C;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,IAAI,EAAE,CAM3D;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,SAAS,IAAI,EAAE,EAAE,CAAC,EAAE,SAAS,IAAI,EAAE,GAAG,OAAO,CAM1E"}