@astrale-os/kernel-core 0.4.1

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

@@ -0,0 +1,30 @@
+import type { ValidationError } from '../parse/validation';
+import { Path } from './path';
+/**
+ * Result shape for {@link safeParsePath}. Symmetric with the Zod
+ * `safeParse` convention used elsewhere in the kernel.
+ */
+export type ParsePathResult = {
+    readonly ok: true;
+    readonly value: Path;
+} | {
+    readonly ok: false;
+    readonly errors: readonly ValidationError[];
+};
+/**
+ * Parse a string into the most-specific typed Path the registry knows
+ * about, or fall back to the base {@link Path} when no type matches.
+ *
+ * Throws {@link PathParseError} on lex/parse failure. The actual lexer
+ * + step-driver lives in {@link parseSteps}; this entry point wraps the
+ * resulting Step[] in a typed class.
+ *
+ * Since the Anchor IR encodes absolute vs relative structurally
+ * (root anchor at `steps[0]` for absolute paths), no out-of-band flag
+ * crosses this boundary — the typed-path discriminator runs purely off
+ * the parsed Step[] shape.
+ */
+export declare function parsePath(input: string): Path;
+/** Parse, returning a result object instead of throwing. */
+export declare function safeParsePath(input: string): ParsePathResult;
+//# sourceMappingURL=parse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../graph/nav/path/parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAK1D,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAE7B;;;GAGG;AACH,MAAM,MAAM,eAAe,GACvB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAA;CAAE,GAC3C;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAA;CAAE,CAAA;AAEvE;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAU7C;AAED,4DAA4D;AAC5D,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAY5D"}

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

@@ -0,0 +1,55 @@
+import { parseSteps } from '../parse/steps';
+import { PathParseError } from './errors';
+import { PathTypeRegistry } from './kinds/registry';
+import { Path } from './path';
+/**
+ * Parse a string into the most-specific typed Path the registry knows
+ * about, or fall back to the base {@link Path} when no type matches.
+ *
+ * Throws {@link PathParseError} on lex/parse failure. The actual lexer
+ * + step-driver lives in {@link parseSteps}; this entry point wraps the
+ * resulting Step[] in a typed class.
+ *
+ * Since the Anchor IR encodes absolute vs relative structurally
+ * (root anchor at `steps[0]` for absolute paths), no out-of-band flag
+ * crosses this boundary — the typed-path discriminator runs purely off
+ * the parsed Step[] shape.
+ */
+export function parsePath(input) {
+    const result = parseSteps(input);
+    if (result.errors.length > 0) {
+        throw new PathParseError(input, result.errors);
+    }
+    const type = PathTypeRegistry.detect(result.steps);
+    if (type) {
+        return type.build(result.steps, input);
+    }
+    return new Path(result.steps, input);
+}
+/** Parse, returning a result object instead of throwing. */
+export function safeParsePath(input) {
+    try {
+        return { ok: true, value: parsePath(input) };
+    }
+    catch (e) {
+        if (e instanceof PathParseError) {
+            return { ok: false, errors: e.errors };
+        }
+        return {
+            ok: false,
+            errors: [{ kind: 'unknown', message: String(e), position: 0 }],
+        };
+    }
+}
+function tryParsePath(input) {
+    try {
+        return parsePath(input);
+    }
+    catch {
+        return null;
+    }
+}
+Path.parse = parsePath;
+Path.tryParse = tryParsePath;
+Path.safeParse = safeParsePath;
+//# sourceMappingURL=parse.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse.js","sourceRoot":"","sources":["../../../../graph/nav/path/parse.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAU7B;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,SAAS,CAAC,KAAa;IACrC,MAAM,MAAM,GAAG,UAAU,CAAC,KAAK,CAAC,CAAA;IAChC,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IAChD,CAAC;IACD,MAAM,IAAI,GAAG,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;IAClD,IAAI,IAAI,EAAE,CAAC;QACT,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;IACxC,CAAC;IACD,OAAO,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;AACtC,CAAC;AAED,4DAA4D;AAC5D,MAAM,UAAU,aAAa,CAAC,KAAa;IACzC,IAAI,CAAC;QACH,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,EAAE,CAAA;IAC9C,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,IAAI,CAAC,YAAY,cAAc,EAAE,CAAC;YAChC,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAA;QACxC,CAAC;QACD,OAAO;YACL,EAAE,EAAE,KAAK;YACT,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC;SAC/D,CAAA;IACH,CAAC;AACH,CAAC;AAED,SAAS,YAAY,CAAC,KAAa;IACjC,IAAI,CAAC;QACH,OAAO,SAAS,CAAC,KAAK,CAAC,CAAA;IACzB,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAA;IACb,CAAC;AACH,CAAC;AAED,IAAI,CAAC,KAAK,GAAG,SAAS,CAAA;AACtB,IAAI,CAAC,QAAQ,GAAG,YAAY,CAAA;AAC5B,IAAI,CAAC,SAAS,GAAG,aAAa,CAAA"}

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

@@ -0,0 +1,41 @@
+import type { Step } from '../ast/step';
+import type { ValidationError } from '../parse/validation';
+/**
+ * Generic, untyped path: a sequence of {@link Step}s with an opaque
+ * canonical string form. Subclasses (AbsolutePath, DomainPath, …) carry
+ * scheme-specific accessors and invariants.
+ *
+ * Relativity is *not* a property of base Path. The structural marker is
+ * the presence (or absence) of a leading {@link Anchor} step:
+ *  - `steps[0]?.kind === 'anchor'` → anchored (absolute / id-anchored).
+ *  - first step is a Traversal → un-anchored (relative).
+ *
+ * Subclasses that need an `isRelative` invariant (RelativePath = true,
+ * AbsolutePath = false, etc.) declare it themselves. Generic code should
+ * branch on `instanceof RelativePath` instead of probing a base getter.
+ */
+export declare class Path {
+    readonly raw: string;
+    private readonly _steps;
+    constructor(steps: readonly Step[], raw: string);
+    get steps(): readonly Step[];
+    static parse(_raw: string): Path;
+    static tryParse(_raw: string): Path | null;
+    static safeParse(_raw: string): {
+        ok: true;
+        value: Path;
+    } | {
+        ok: false;
+        errors: readonly ValidationError[];
+    };
+    toString(): string;
+    toJSON(): string;
+    equals(other: Path): boolean;
+}
+/**
+ * Coerce `Path | string` → `Path`. Used at runtime boundaries where a
+ * param may arrive as a wire-serialized string (JSON) or an in-process
+ * Path instance. Throws `PathParseError` if the string is invalid.
+ */
+export declare function toPath(value: Path | string): Path;
+//# sourceMappingURL=path.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../../../graph/nav/path/path.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAI1D;;;;;;;;;;;;;GAaG;AACH,qBAAa,IAAI;IACf,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IAExC,YAAY,KAAK,EAAE,SAAS,IAAI,EAAE,EAAE,GAAG,EAAE,MAAM,EAG9C;IAED,IAAI,KAAK,IAAI,SAAS,IAAI,EAAE,CAE3B;IAOD,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAE/B;IAED,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAEzC;IAED,MAAM,CAAC,SAAS,CACd,IAAI,EAAE,MAAM,GACX;QAAE,EAAE,EAAE,IAAI,CAAC;QAAC,KAAK,EAAE,IAAI,CAAA;KAAE,GAAG;QAAE,EAAE,EAAE,KAAK,CAAC;QAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAA;KAAE,CAE/E;IAED,QAAQ,IAAI,MAAM,CAEjB;IAED,MAAM,IAAI,MAAM,CAEf;IAED,MAAM,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO,CAG3B;CACF;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAEjD"}

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

@@ -0,0 +1,59 @@
+import { stepsEqual } from '../ast/step/reverse';
+/**
+ * Generic, untyped path: a sequence of {@link Step}s with an opaque
+ * canonical string form. Subclasses (AbsolutePath, DomainPath, …) carry
+ * scheme-specific accessors and invariants.
+ *
+ * Relativity is *not* a property of base Path. The structural marker is
+ * the presence (or absence) of a leading {@link Anchor} step:
+ *  - `steps[0]?.kind === 'anchor'` → anchored (absolute / id-anchored).
+ *  - first step is a Traversal → un-anchored (relative).
+ *
+ * Subclasses that need an `isRelative` invariant (RelativePath = true,
+ * AbsolutePath = false, etc.) declare it themselves. Generic code should
+ * branch on `instanceof RelativePath` instead of probing a base getter.
+ */
+export class Path {
+    raw;
+    _steps;
+    constructor(steps, raw) {
+        this._steps = steps;
+        this.raw = raw;
+    }
+    get steps() {
+        return this._steps;
+    }
+    // Static parsing entry points are installed at module load time by
+    // `./parse.ts` — the implementations live there to avoid a circular
+    // module dep (parse → registry → defaults → path). Calling these
+    // before `parse.ts` has been side-effect-imported throws.
+    static parse(_raw) {
+        throw new Error('Path.parse: not yet bound — import from #graph/nav/path');
+    }
+    static tryParse(_raw) {
+        throw new Error('Path.tryParse: not yet bound — import from #graph/nav/path');
+    }
+    static safeParse(_raw) {
+        throw new Error('Path.safeParse: not yet bound — import from #graph/nav/path');
+    }
+    toString() {
+        return this.raw;
+    }
+    toJSON() {
+        return this.raw;
+    }
+    equals(other) {
+        if (this.raw === other.raw)
+            return true;
+        return stepsEqual(this.steps, other.steps);
+    }
+}
+/**
+ * Coerce `Path | string` → `Path`. Used at runtime boundaries where a
+ * param may arrive as a wire-serialized string (JSON) or an in-process
+ * Path instance. Throws `PathParseError` if the string is invalid.
+ */
+export function toPath(value) {
+    return typeof value === 'string' ? Path.parse(value) : value;
+}
+//# sourceMappingURL=path.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"path.js","sourceRoot":"","sources":["../../../../graph/nav/path/path.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAEhD;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,IAAI;IACN,GAAG,CAAQ;IACH,MAAM,CAAiB;IAExC,YAAY,KAAsB,EAAE,GAAW;QAC7C,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;QACnB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAA;IAChB,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAA;IACpB,CAAC;IAED,mEAAmE;IACnE,oEAAoE;IACpE,iEAAiE;IACjE,0DAA0D;IAE1D,MAAM,CAAC,KAAK,CAAC,IAAY;QACvB,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAA;IAC5E,CAAC;IAED,MAAM,CAAC,QAAQ,CAAC,IAAY;QAC1B,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAA;IAC/E,CAAC;IAED,MAAM,CAAC,SAAS,CACd,IAAY;QAEZ,MAAM,IAAI,KAAK,CAAC,6DAA6D,CAAC,CAAA;IAChF,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,GAAG,CAAA;IACjB,CAAC;IAED,MAAM;QACJ,OAAO,IAAI,CAAC,GAAG,CAAA;IACjB,CAAC;IAED,MAAM,CAAC,KAAW;QAChB,IAAI,IAAI,CAAC,GAAG,KAAK,KAAK,CAAC,GAAG;YAAE,OAAO,IAAI,CAAA;QACvC,OAAO,UAAU,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;IAC5C,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,UAAU,MAAM,CAAC,KAAoB;IACzC,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAA;AAC9D,CAAC"}

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

@@ -0,0 +1,99 @@
+/**
+ * Wire-safe Zod schemas for Path and its subtypes.
+ *
+ * `z.custom<Path>()` declares a TS type but performs no validation — the value
+ * passes through as whatever the wire sent (typically a string). Call sites
+ * then compensated with `toPath(params.x)` everywhere, which was noisy and
+ * misleading: the handler saw `params.x: Path` but received a string at runtime.
+ *
+ * The `pathLike` factory replaces `z.custom<T>()` with real schemas that:
+ *   - accept a Path subtype instance (in-process callers — identity passthrough),
+ *   - parse raw strings via `Path.parse` (wire callers — auto-detects the most
+ *     specific subtype through `PathTypeRegistry`),
+ *   - narrow the result with `instanceof` and reject foreign subtypes with a
+ *     typed mismatch issue,
+ *   - surface rich, per-field parser diagnostics (position, kind, raw input),
+ *   - serialize to JSON schema as `{ type: 'string', format: 'path:*' }` via
+ *     `.meta(...)` so documentation generators see the wire shape, not the
+ *     `Path` class object.
+ *
+ * This file owns the base `pathLike` factory plus the `pathSchema` (base Path)
+ * and `idPathSchema` factories. Subdomain-specific factories live with their
+ * types:
+ *   - `#graph/tree/zod` — TreePath, AbsolutePath, RelativePath
+ *   - `#domain/addressing/paths/zod` — ClassPath, DomainPath, MethodPath, InstanceMethodPath
+ */
+import './parse';
+import { z } from 'zod';
+import { IdPath } from './kinds/id-path';
+import { Path } from './path';
+/**
+ * Machine-readable failure reasons for path-schema validation.
+ *
+ * Kept narrow on purpose: the schema layer only produces `parse` (delegates
+ * to `Path.parse` with its own kind strings inside `parseErrors`) and
+ * `subtype-mismatch` (the raw parsed successfully but the resulting instance
+ * is not of the declared subtype).
+ */
+export type PathValidationErrorKind = 'parse' | 'subtype-mismatch' | 'unexpected-type';
+/**
+ * Per-issue detail carried on a `PathValidationError`.
+ *
+ * Mirrors the shape emitted into Zod `params` so the same payload surfaces
+ * through `ZodError.issues[*].params` and through this class when callers
+ * parse paths outside Zod.
+ */
+export interface PathValidationIssue {
+    readonly kind: PathValidationErrorKind;
+    readonly message: string;
+    /** Character offset from `Path.parse`; only set when `kind === 'parse'`. */
+    readonly position?: number;
+    /** Actual subtype name; only set when `kind === 'subtype-mismatch'`. */
+    readonly actual?: string;
+}
+/**
+ * Typed error for out-of-band path parsing (outside Zod contexts).
+ *
+ * Handlers don't usually see this — Zod surfaces issues through its own
+ * `ZodError` path. It exists so runtime code that needs to parse a string
+ * as a specific Path subtype (e.g., adapters, migration tooling) has a
+ * single, structured failure mode instead of ad-hoc strings.
+ */
+export declare class PathValidationError extends Error {
+    readonly raw: unknown;
+    readonly expected: string;
+    readonly issues: readonly PathValidationIssue[];
+    readonly name = "PathValidationError";
+    constructor(raw: unknown, expected: string, issues: readonly PathValidationIssue[]);
+}
+/**
+ * Path subtypes intentionally hide their constructors (`private` / `protected`)
+ * and expose construction through static factories. A plain `new (...) => T`
+ * signature would reject those classes here, even though `instanceof` works
+ * fine at runtime. Use a structural shape instead — every class carries
+ * `prototype` and `name`, regardless of constructor visibility.
+ */
+export interface PathCtor<T extends Path> {
+    readonly prototype: T;
+    readonly name: string;
+}
+/**
+ * Build a Zod schema that accepts `T | string` and outputs `T`, where `T` is
+ * a concrete Path subtype.
+ *
+ * `format` is the JSON-Schema `format` string emitted by `.meta(...)` — by
+ * convention `path:<variant>` (e.g. `path:tree.absolute`). Each Path subtype's
+ * factory module owns its own tag; this base layer stays unaware of which
+ * variants exist. The reverse map in `runtime/functions/serializer/to-zod.ts`
+ * is the single side that needs to enumerate them, and it does so by string.
+ *
+ * Uses `z.preprocess` rather than a union so the error surface is a single,
+ * authoritative branch — unions pollute issues with per-branch failures that
+ * obscure the real cause for wire callers.
+ */
+export declare function pathLike<T extends Path>(Ctor: PathCtor<T>, expected: string, format: string): () => z.ZodType<T, T | string>;
+/** Accepts any Path instance or a wire-serialized path string. */
+export declare const pathSchema: () => z.ZodType<Path, string | Path, z.core.$ZodTypeInternals<Path, string | Path>>;
+/** IdPath only (node identifier path). */
+export declare const idPathSchema: () => z.ZodType<IdPath, string | IdPath, z.core.$ZodTypeInternals<IdPath, string | IdPath>>;
+//# sourceMappingURL=zod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zod.d.ts","sourceRoot":"","sources":["../../../../graph/nav/path/zod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAMH,OAAO,SAAS,CAAA;AAChB,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAI7B;;;;;;;GAOG;AACH,MAAM,MAAM,uBAAuB,GAAG,OAAO,GAAG,kBAAkB,GAAG,iBAAiB,CAAA;AAEtF;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,uBAAuB,CAAA;IACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,4EAA4E;IAC5E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC1B,wEAAwE;IACxE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CACzB;AAED;;;;;;;GAOG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;aAG1B,GAAG,EAAE,OAAO;aACZ,QAAQ,EAAE,MAAM;aAChB,MAAM,EAAE,SAAS,mBAAmB,EAAE;IAJxD,SAAkB,IAAI,yBAAwB;IAC9C,YACkB,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,SAAS,mBAAmB,EAAE,EAMvD;CACF;AAID;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS,IAAI;IACtC,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAKD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,IAAI,EACrC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EACjB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,CAqDhC;AAUD,kEAAkE;AAClE,eAAO,MAAM,UAAU,qFAAiC,CAAA;AAExD,0CAA0C;AAC1C,eAAO,MAAM,YAAY,6FAAwC,CAAA"}

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

@@ -0,0 +1,132 @@
+/**
+ * Wire-safe Zod schemas for Path and its subtypes.
+ *
+ * `z.custom<Path>()` declares a TS type but performs no validation — the value
+ * passes through as whatever the wire sent (typically a string). Call sites
+ * then compensated with `toPath(params.x)` everywhere, which was noisy and
+ * misleading: the handler saw `params.x: Path` but received a string at runtime.
+ *
+ * The `pathLike` factory replaces `z.custom<T>()` with real schemas that:
+ *   - accept a Path subtype instance (in-process callers — identity passthrough),
+ *   - parse raw strings via `Path.parse` (wire callers — auto-detects the most
+ *     specific subtype through `PathTypeRegistry`),
+ *   - narrow the result with `instanceof` and reject foreign subtypes with a
+ *     typed mismatch issue,
+ *   - surface rich, per-field parser diagnostics (position, kind, raw input),
+ *   - serialize to JSON schema as `{ type: 'string', format: 'path:*' }` via
+ *     `.meta(...)` so documentation generators see the wire shape, not the
+ *     `Path` class object.
+ *
+ * This file owns the base `pathLike` factory plus the `pathSchema` (base Path)
+ * and `idPathSchema` factories. Subdomain-specific factories live with their
+ * types:
+ *   - `#graph/tree/zod` — TreePath, AbsolutePath, RelativePath
+ *   - `#domain/addressing/paths/zod` — ClassPath, DomainPath, MethodPath, InstanceMethodPath
+ */
+// Side-effect import: binds Path.parse / Path.tryParse / Path.safeParse statics
+// before any consumer evaluates a `pathLike` thunk. Bind here (rather than relying
+// on barrel order) so direct imports of `path/zod.ts` work regardless of the
+// consumer's import graph.
+import './parse';
+import { z } from 'zod';
+import { IdPath } from './kinds/id-path';
+import { Path } from './path';
+/**
+ * Typed error for out-of-band path parsing (outside Zod contexts).
+ *
+ * Handlers don't usually see this — Zod surfaces issues through its own
+ * `ZodError` path. It exists so runtime code that needs to parse a string
+ * as a specific Path subtype (e.g., adapters, migration tooling) has a
+ * single, structured failure mode instead of ad-hoc strings.
+ */
+export class PathValidationError extends Error {
+    raw;
+    expected;
+    issues;
+    name = 'PathValidationError';
+    constructor(raw, expected, issues) {
+        const summary = issues
+            .map((i) => (i.position !== undefined ? `${i.message} (at ${i.position})` : i.message))
+            .join('; ');
+        super(`Invalid ${expected}: ${summary || 'unknown error'}`);
+        this.raw = raw;
+        this.expected = expected;
+        this.issues = issues;
+    }
+}
+/**
+ * Build a Zod schema that accepts `T | string` and outputs `T`, where `T` is
+ * a concrete Path subtype.
+ *
+ * `format` is the JSON-Schema `format` string emitted by `.meta(...)` — by
+ * convention `path:<variant>` (e.g. `path:tree.absolute`). Each Path subtype's
+ * factory module owns its own tag; this base layer stays unaware of which
+ * variants exist. The reverse map in `runtime/functions/serializer/to-zod.ts`
+ * is the single side that needs to enumerate them, and it does so by string.
+ *
+ * Uses `z.preprocess` rather than a union so the error surface is a single,
+ * authoritative branch — unions pollute issues with per-branch failures that
+ * obscure the real cause for wire callers.
+ */
+export function pathLike(Ctor, expected, format) {
+    const instanceCtor = Ctor;
+    return () => z
+        .preprocess((raw, ctx) => {
+        if (raw instanceof instanceCtor)
+            return raw;
+        if (raw instanceof Path) {
+            ctx.issues.push({
+                code: 'custom',
+                message: `expected ${expected}, got ${raw.constructor.name}`,
+                input: raw,
+                params: { kind: 'subtype-mismatch', actual: raw.constructor.name },
+            });
+            return undefined;
+        }
+        if (typeof raw !== 'string') {
+            ctx.issues.push({
+                code: 'custom',
+                message: `expected ${expected} or wire string, got ${describe(raw)}`,
+                input: raw,
+                params: { kind: 'unexpected-type' },
+            });
+            return undefined;
+        }
+        const parsed = Path.safeParse(raw);
+        if (!parsed.ok) {
+            for (const err of parsed.errors) {
+                ctx.issues.push({
+                    code: 'custom',
+                    message: err.message,
+                    input: raw,
+                    params: { kind: 'parse', position: err.position, parserKind: err.kind },
+                });
+            }
+            return undefined;
+        }
+        if (!(parsed.value instanceof instanceCtor)) {
+            ctx.issues.push({
+                code: 'custom',
+                message: `expected ${expected}, got ${parsed.value.constructor.name} (from "${raw}")`,
+                input: raw,
+                params: { kind: 'subtype-mismatch', actual: parsed.value.constructor.name },
+            });
+            return undefined;
+        }
+        return parsed.value;
+    }, z.instanceof(instanceCtor))
+        .meta({ type: 'string', format });
+}
+function describe(v) {
+    if (v === null)
+        return 'null';
+    if (Array.isArray(v))
+        return 'array';
+    return typeof v;
+}
+// ── Per-subtype factories (base + id) ──────────────────────────────────────
+/** Accepts any Path instance or a wire-serialized path string. */
+export const pathSchema = pathLike(Path, 'Path', 'path');
+/** IdPath only (node identifier path). */
+export const idPathSchema = pathLike(IdPath, 'IdPath', 'path:id');
+//# sourceMappingURL=zod.js.map

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

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

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

@@ -0,0 +1,6 @@
+export type { Hop, SchemeSegment, SingleHop, RecursiveHop } from './segment';
+export { SchemeRegistry } from './registry';
+export { span } from './span';
+export { walk, type SegmentWalkResult } from './walk';
+export { traversalFromHop, reconstructSteps } from './slug';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../graph/nav/scheme/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,GAAG,EAAE,aAAa,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAC5E,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAC3C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC7B,OAAO,EAAE,IAAI,EAAE,KAAK,iBAAiB,EAAE,MAAM,QAAQ,CAAA;AACrD,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAA"}

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

@@ -0,0 +1,5 @@
+export { SchemeRegistry } from './registry';
+export { span } from './span';
+export { walk } from './walk';
+export { traversalFromHop, reconstructSteps } from './slug';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../graph/nav/scheme/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAC3C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC7B,OAAO,EAAE,IAAI,EAA0B,MAAM,QAAQ,CAAA;AACrD,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAA"}

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

@@ -0,0 +1,17 @@
+import type { SchemeSegment } from './segment';
+/**
+ * Registry of available scheme segments.
+ *
+ * Segments are registered by name; the registry is mostly a lookup for
+ * tooling and tests. PathTypes hold direct references to their
+ * segments, so segment composition does not depend on registry order.
+ */
+export declare class SchemeRegistry {
+    private static readonly _segments;
+    static register(seg: SchemeSegment): void;
+    static get(name: string): SchemeSegment | undefined;
+    static all(): readonly SchemeSegment[];
+    /** Reset registry state. For testing only. */
+    static _reset(): void;
+}
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../graph/nav/scheme/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAE9C;;;;;;GAMG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAmC;IAEpE,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CAExC;IAED,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAElD;IAED,MAAM,CAAC,GAAG,IAAI,SAAS,aAAa,EAAE,CAErC;IAED,8CAA8C;IAC9C,MAAM,CAAC,MAAM,IAAI,IAAI,CAEpB;CACF"}

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

@@ -0,0 +1,24 @@
+/**
+ * Registry of available scheme segments.
+ *
+ * Segments are registered by name; the registry is mostly a lookup for
+ * tooling and tests. PathTypes hold direct references to their
+ * segments, so segment composition does not depend on registry order.
+ */
+export class SchemeRegistry {
+    static _segments = new Map();
+    static register(seg) {
+        SchemeRegistry._segments.set(seg.name, seg);
+    }
+    static get(name) {
+        return SchemeRegistry._segments.get(name);
+    }
+    static all() {
+        return Array.from(SchemeRegistry._segments.values());
+    }
+    /** Reset registry state. For testing only. */
+    static _reset() {
+        SchemeRegistry._segments.clear();
+    }
+}
+//# sourceMappingURL=registry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../../graph/nav/scheme/registry.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,OAAO,cAAc;IACjB,MAAM,CAAU,SAAS,GAAG,IAAI,GAAG,EAAyB,CAAA;IAEpE,MAAM,CAAC,QAAQ,CAAC,GAAkB;QAChC,cAAc,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;IAC7C,CAAC;IAED,MAAM,CAAC,GAAG,CAAC,IAAY;QACrB,OAAO,cAAc,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;IAC3C,CAAC;IAED,MAAM,CAAC,GAAG;QACR,OAAO,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,CAAA;IACtD,CAAC;IAED,8CAA8C;IAC9C,MAAM,CAAC,MAAM;QACX,cAAc,CAAC,SAAS,CAAC,KAAK,EAAE,CAAA;IAClC,CAAC;CACF"}

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

@@ -0,0 +1,53 @@
+import type { Anchor } from '#graph/nav/path/step';
+/**
+ * One edge traversal — the atomic primitive of a scheme segment.
+ *
+ * Pure data: which edge type to follow, and which direction the
+ * forward Step IR walker traverses it. The physical walk at identify
+ * time is always outgoing from the current node (kernel schema
+ * invariant: source = leaf side, target = anchor side).
+ */
+export interface Hop {
+    readonly edge: string;
+    readonly direction: 'inbound' | 'outbound';
+}
+/**
+ * A scheme segment in two declarative shapes.
+ *
+ * `kind: 'single'` — applies the hop exactly once. The landed node
+ * becomes the predecessor for the next outer segment in the chain.
+ *
+ * `kind: 'recursive'` — applies the hop transitively until no more
+ * edges. Emits the bound `anchor` as the leading IR step. Terminates
+ * the chain (predecessor = null).
+ *
+ * Both forward (`./span`) and backward (`./walk`) operations are
+ * derived generically from this data. Cypher emission for adapter-side
+ * query generation is similarly derived (see
+ * `kernel/adapters/graph/path/resolver/cypher.ts`); both backends
+ * converge on the slug array described in `./slug`.
+ */
+export type SchemeSegment = SingleHop | RecursiveHop;
+export interface SingleHop {
+    readonly kind: 'single';
+    readonly name: string;
+    readonly hop: Hop;
+}
+export interface RecursiveHop {
+    readonly kind: 'recursive';
+    readonly name: string;
+    readonly hop: Hop;
+    /**
+     * Anchor emitted at the chain's start, marking the recursion
+     * terminus. For the absolute scheme this is `ROOT_ANCHOR`.
+     */
+    readonly anchor: Anchor;
+    /**
+     * Expected `ReaderNode.path` of the node the walk terminates on.
+     * `walk` throws when the recursion runs out of edges at a node whose
+     * `.path` differs (orphan / broken chain). For the absolute scheme
+     * this is `'/'`.
+     */
+    readonly terminus: string;
+}
+//# sourceMappingURL=segment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../../graph/nav/scheme/segment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAElD;;;;;;;GAOG;AACH,MAAM,WAAW,GAAG;IAClB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,SAAS,EAAE,SAAS,GAAG,UAAU,CAAA;CAC3C;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,YAAY,CAAA;AAEpD,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;IACjB;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B"}

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

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

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

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

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

@@ -0,0 +1,40 @@
+/**
+ * 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 type { Step, Traversal } from '../ast/step';
+import type { PathType } from '../path/kinds/path-type';
+import type { Hop } from './segment';
+/**
+ * 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 declare function traversalFromHop(hop: Hop, slug: string): Traversal;
+/**
+ * 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 declare function reconstructSteps(type: PathType, slugs: readonly string[]): Step[];
+//# sourceMappingURL=slug.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slug.d.ts","sourceRoot":"","sources":["../../../../graph/nav/scheme/slug.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,KAAK,EAAE,GAAG,EAA2B,MAAM,WAAW,CAAA;AAK7D;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CAclE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,EAAE,CAyBjF"}