@astrale-os/kernel-core 0.9.0-beta.8 → 1.0.0-beta.1

package/dist/graph/mutate/result/error.js

@@ -7,4 +7,3 @@ export class MutationResultDecodeError extends TypeError {
         this.name = 'MutationResultDecodeError';
     }
 }
-//# sourceMappingURL=error.js.map

package/dist/graph/mutate/result/index.d.ts

@@ -1,16 +1,17 @@
 import type { NodeId } from '../../node/index.js';
-import type { LocalBinding } from '../language/index.js';
+import type { LocalAlias } from '../language/index.js';
 export type MutationResult = {
-    readonly createdNodes: Readonly<Record<LocalBinding, NodeId>>;
+    readonly createdNodes: Readonly<Record<LocalAlias, NodeId>>;
+    readonly replayed?: true;
 };
 export declare const MutationResult: {
     decode(input: unknown): MutationResult;
     encode(input: MutationResult): MutationResult;
+    createdNode(result: MutationResult, binding: string): NodeId | undefined;
 };
 export { MutationResultDecodeError } from './error.js';
 export { mutationResultSchema } from './wire.js';
 /** Re-admit one mutation result before it crosses a trust or transport boundary. */
 export declare function encodeMutationResult(input: MutationResult): MutationResult;
-/** Decode unknown JSON into immutable admitted LocalBinding-to-NodeId results. */
+/** Decode unknown JSON into immutable admitted LocalAlias-to-NodeId results. */
 export declare function decodeMutationResult(input: unknown): MutationResult;
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/mutate/result/index.js

@@ -1,20 +1,27 @@
 import * as portable from '@astrale-os/kernel-dsl/value';
-import { isLocalBinding } from '#graph/graph';
+import { isLocalAlias, LocalAlias as LocalAliasValue } from '#graph/graph';
 import { NodeId as nodeId } from '../../node/index.js';
 import { decodeWire } from '../../wire.js';
 import { MutationResultDecodeError } from './error.js';
 import { mutationResultSchema } from './wire.js';
-export const MutationResult = Object.freeze({ decode: decodeMutationResult, encode: encodeMutationResult });
+export const MutationResult = Object.freeze({
+    decode: decodeMutationResult,
+    encode: encodeMutationResult,
+    createdNode(result, binding) {
+        return result.createdNodes[LocalAliasValue(binding)];
+    },
+});
 export { MutationResultDecodeError } from './error.js';
 export { mutationResultSchema } from './wire.js';
 /** Re-admit one mutation result before it crosses a trust or transport boundary. */
 export function encodeMutationResult(input) {
     return decodeMutationResult(input);
 }
-/** Decode unknown JSON into immutable admitted LocalBinding-to-NodeId results. */
+/** Decode unknown JSON into immutable admitted LocalAlias-to-NodeId results. */
 export function decodeMutationResult(input) {
     try {
-        const encoded = decodeWire(mutationResultSchema, portable.accept(input), invalid).createdNodes;
+        const admitted = decodeWire(mutationResultSchema, portable.accept(input), invalid);
+        const encoded = admitted.createdNodes;
         const createdNodes = {};
         for (const binding of Object.keys(encoded).sort()) {
             const path = `/createdNodes/${escapePointer(binding)}`;
@@ -29,6 +36,7 @@ export function decodeMutationResult(input) {
         }
         return Object.freeze({
             createdNodes: Object.freeze(createdNodes),
+            ...(admitted.replayed === true ? { replayed: true } : {}),
         });
     }
     catch (error) {
@@ -40,8 +48,8 @@ export function decodeMutationResult(input) {
     }
 }
 function requireBinding(value, path) {
-    if (!isLocalBinding(value))
-        invalid(path, 'Invalid LocalBinding');
+    if (!isLocalAlias(value))
+        invalid(path, 'Invalid LocalAlias');
 }
 function escapePointer(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
@@ -52,4 +60,3 @@ function invalid(path, message, cause) {
 function errorPointer(error) {
     return error instanceof portable.BoundaryError ? error.pointer : '';
 }
-//# sourceMappingURL=index.js.map

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

@@ -1,5 +1,4 @@
-import { z } from 'zod';
-export declare const mutationResultSchema: z.ZodObject<{
-    createdNodes: z.ZodRecord<z.ZodString, z.ZodString>;
-}, z.core.$strict>;
-//# sourceMappingURL=wire.d.ts.map
+export declare const mutationResultSchema: import("zod").ZodObject<{
+    createdNodes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+    replayed: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+}, import("zod/v4/core").$strict>;

package/dist/graph/mutate/result/wire.js

@@ -1,5 +1,7 @@
-import { z } from 'zod';
-const text = z.string().min(1);
-const binding = z.string().min(1).max(64);
-export const mutationResultSchema = z.strictObject({ createdNodes: z.record(binding, text) });
-//# sourceMappingURL=wire.js.map
+import { literal, record, strictObject, string } from 'zod';
+const text = string().min(1);
+const binding = string().min(1).max(64);
+export const mutationResultSchema = strictObject({
+    createdNodes: record(binding, text),
+    replayed: literal(true).optional(),
+});

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

@@ -1,4 +1,3 @@
 /** Private compatibility facade for callable-admission Zod carriers. */
 export { mutationAstSchema } from '../language/index.js';
 export { mutationResultSchema } from '../result/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/mutate/wire/index.js

@@ -1,4 +1,3 @@
 /** Private compatibility facade for callable-admission Zod carriers. */
 export { mutationAstSchema } from '../language/index.js';
 export { mutationResultSchema } from '../result/index.js';
-//# sourceMappingURL=index.js.map

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

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 declare const NODE_ID_BRAND: unique symbol;
 /** Stable opaque identity: 1-255 ASCII characters from [A-Za-z0-9._-]. */
 export type NodeId = string & {
@@ -12,8 +11,4 @@ export declare class NodeIdError extends TypeError {
 /** Admit opaque 1-255 character ASCII NodeId text without repair or format-specific semantics. */
 export declare function NodeId(input: string): NodeId;
 export declare function isNodeId(input: unknown): input is NodeId;
-export declare const nodeIdSchema: z.ZodPipe<z.ZodString & z.ZodType<NodeId, string, z.core.$ZodTypeInternals<NodeId, string>>, z.ZodTransform<NodeId, string & {
-    readonly [NODE_ID_BRAND]: true;
-}>>;
 export {};
-//# sourceMappingURL=id.d.ts.map

package/dist/graph/node/identity/id.js

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 const NODE_ID_MAX_LENGTH = 255;
 const NODE_ID_INVALID_CHARACTER = /[^A-Za-z0-9._-]/u;
 const NODE_ID_ERROR_MESSAGE = 'NodeId must be 1-255 ASCII characters drawn from [A-Za-z0-9._-].';
@@ -23,8 +22,3 @@ export function isNodeId(input) {
         input.length <= NODE_ID_MAX_LENGTH &&
         !NODE_ID_INVALID_CHARACTER.test(input));
 }
-export const nodeIdSchema = z
-    .string()
-    .refine(isNodeId, NODE_ID_ERROR_MESSAGE)
-    .transform((value) => value);
-//# sourceMappingURL=id.js.map

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

@@ -1,3 +1,2 @@
 export { NodeId, NodeIdError, isNodeId } from './id.js';
 export { compareNodeIds } from './order.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,3 +1,2 @@
 export { NodeId, NodeIdError, isNodeId } from './id.js';
 export { compareNodeIds } from './order.js';
-//# sourceMappingURL=index.js.map

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

@@ -1,4 +1,3 @@
 import type { NodeId } from './id.js';
 /** Compare canonical Node identity by unsigned lexicographic UTF-8 byte order. */
 export declare function compareNodeIds(left: NodeId, right: NodeId): number;
-//# sourceMappingURL=order.d.ts.map

package/dist/graph/node/identity/order.js

@@ -1,6 +1,26 @@
 const encoder = new TextEncoder();
 /** Compare canonical Node identity by unsigned lexicographic UTF-8 byte order. */
 export function compareNodeIds(left, right) {
+    // UTF-8 preserves code point order, and identical UTF-16 prefixes encode identically. Below the
+    // surrogate block, the first differing code unit therefore decides the UTF-8 byte order.
+    const length = Math.min(left.length, right.length);
+    let index = 0;
+    while (index < length && left.charCodeAt(index) === right.charCodeAt(index))
+        index++;
+    if (index < length) {
+        const a = left.charCodeAt(index);
+        const b = right.charCodeAt(index);
+        if (a < 0xd800 && b < 0xd800)
+            return a < b ? -1 : 1;
+    }
+    else {
+        const next = (left.length > right.length ? left : right).charCodeAt(index);
+        if (Number.isNaN(next) || next < 0xdc00 || next > 0xdfff)
+            return Math.sign(left.length - right.length);
+    }
+    return compareUtf8(left, right);
+}
+function compareUtf8(left, right) {
     const a = encoder.encode(left);
     const b = encoder.encode(right);
     const length = Math.min(a.length, b.length);
@@ -11,4 +31,3 @@ export function compareNodeIds(left, right) {
     }
     return Math.sign(a.length - b.length);
 }
-//# sourceMappingURL=order.js.map

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

@@ -2,4 +2,3 @@
 export { NodeId, NodeIdError, compareNodeIds, isNodeId } from './identity/index.js';
 export { node } from './model/index.js';
 export type { Node, NodeCollection, NodeSpec } from './model/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/node/index.js

@@ -1,4 +1,3 @@
 /** Stable aggregate facade over Node identity and model semantics. */
 export { NodeId, NodeIdError, compareNodeIds, isNodeId } from './identity/index.js';
 export { node } from './model/index.js';
-//# sourceMappingURL=index.js.map

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

@@ -13,4 +13,3 @@ export interface Node extends NodeSpec {
 /** Construct one immutable Node record from canonical components. */
 export declare function node(value: Node): Node;
 export type NodeCollection = readonly Node[];
-//# sourceMappingURL=index.d.ts.map

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

@@ -2,4 +2,3 @@
 export function node(value) {
     return Object.freeze({ id: value.id, class: value.class, props: value.props });
 }
-//# sourceMappingURL=index.js.map

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

@@ -1,3 +1,2 @@
 export { Path } from './path.js';
 export type { CallablePath, NodeTarget, PathLike } from './path.js';
-//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,4 +1,5 @@
-import type { CoreRef, DefinitionRef, Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { DefinitionRef, Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import { MethodKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { type ClassKey as ClassKeyValue } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { NodeId } from '../../node/identity/index.js';
 import type { DomainAnchor as PathDomainAnchor, DomainProjection as PathDomainProjection, IdAnchor as PathIdAnchor, MethodStep as PathMethodStep, NodePath, PathAST, PathAnchor, PathDiagnostic, PathDiagnosticCode, PathStep, ProjectionKind as PathProjectionKind, ProjectionStep as PathProjectionStep, TraversalStep as PathTraversalStep } from '../language/index.js';
@@ -11,13 +12,15 @@ export declare class Path {
     private constructor();
     /** Retain an admitted rich Path or parse its canonical serialized form. */
     static from(input: PathLike): Path;
+    /** Normalize an exact graph target without resolving its installed Node identity. */
+    static target(input: NodeTarget): Path;
     static parse(input: string): Path;
     static fromAST(ast: Path.AST): Path;
     static id(id: NodeId): Path.Id;
     static domain(origin: Key.Origin): Path.Domain;
     static project(input: ClassKeyValue | Path.ProjectionRef): Path.Projection;
     static staticMethod(owner: Path.Projection, name: string): Path.Method;
-    static instanceMethod(source: Path, name: string): Path.Method;
+    static instanceMethod(source: Path, callable: MethodKey): Path.Method;
     out(classKey: ClassKeyValue, options?: Path.TraversalOptions): Path;
     in(classKey: ClassKeyValue, options?: Path.TraversalOptions): Path;
     equals(other: Path): boolean;
@@ -27,8 +30,8 @@ export declare class Path {
 }
 /** Rich or already-admitted serialized Path accepted at in-process authoring boundaries. */
 export type PathLike = Path | NodePath;
-/** Exact existing Node accepted by ID-first graph authoring facades. */
-export type NodeTarget = NodeId | PathLike;
+/** Exact existing Node; DefinitionRefs address their projected graph nodes, not Class extents. */
+export type NodeTarget = NodeId | PathLike | DefinitionRef;
 /** Runtime-established proof that a Path addresses one callable Node. */
 export type CallablePath = Path & {
     readonly [CALLABLE_PATH]: true;
@@ -46,7 +49,7 @@ export declare namespace Path {
     type ProjectionKind = PathProjectionKind;
     type DomainProjection = PathDomainProjection;
     /** Structured coordinate accepted for a graph-projected Definition or Core object. */
-    type ProjectionRef = DefinitionRef<'class' | 'function' | 'policy' | 'view'> | CoreRef;
+    type ProjectionRef = DefinitionRef;
     interface TraversalOptions {
         readonly slug?: EdgeSlugValue;
     }
@@ -69,4 +72,3 @@ export declare namespace Path {
     type Diagnostic = PathDiagnostic;
 }
 export {};
-//# sourceMappingURL=path.d.ts.map

package/dist/graph/path/authoring/path.js

@@ -1,5 +1,7 @@
-import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import { MethodKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import { ClassKey, isDefinitionRef, } from '@astrale-os/kernel-dsl/v1/addressing';
 import { EdgeSlug } from '../../edge/slug/index.js';
+import { isNodeId } from '../../node/identity/index.js';
 import { normalizePathAST, parsePathAST, pathError, serializePathAST } from '../language/index.js';
 /** Immutable rich value for one admitted NodePath. */
 export class Path {
@@ -10,6 +12,18 @@ export class Path {
     static from(input) {
         return input instanceof Path ? input : Path.parse(input);
     }
+    /** Normalize an exact graph target without resolving its installed Node identity. */
+    static target(input) {
+        if (input instanceof Path)
+            return input;
+        if (isNodeId(input))
+            return Path.id(input);
+        if (typeof input === 'string')
+            return Path.parse(input);
+        if (isDefinitionRef(input))
+            return Path.project(input);
+        throw pathError(input, 'PATH_INVALID_PROJECTION', 'Node target requires an ID, Path, or DefinitionRef.');
+    }
     static parse(input) {
         return createPath(parsePathAST(input));
     }
@@ -38,10 +52,14 @@ export class Path {
             steps: [...owner.ast.steps, { kind: 'method', dispatch: 'static', name }],
         }));
     }
-    static instanceMethod(source, name) {
+    static instanceMethod(source, callable) {
+        const { owner, name } = MethodKey.address(callable);
         return createPath(normalizePathAST({
             anchor: source.ast.anchor,
-            steps: [...source.ast.steps, { kind: 'method', dispatch: 'instance', name }],
+            steps: [
+                ...source.ast.steps,
+                { kind: 'method', dispatch: 'instance', class: ClassKey.of(owner), name },
+            ],
         }));
     }
     out(classKey, options = {}) {
@@ -118,4 +136,3 @@ function defineRefinement(path) {
 function define(target, key, value) {
     Object.defineProperty(target, key, { enumerable: true, value });
 }
-//# sourceMappingURL=path.js.map

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

@@ -2,4 +2,3 @@
 export { Path } from './authoring/index.js';
 export type { CallablePath, NodeTarget, PathLike } from './authoring/index.js';
 export { NodePath, PathError, isNodePath } from './language/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/path/index.js

@@ -1,4 +1,3 @@
 /** Stable aggregate facade over the NodePath language and rich Path authoring value. */
 export { Path } from './authoring/index.js';
 export { NodePath, PathError, isNodePath } from './language/index.js';
-//# sourceMappingURL=index.js.map

package/dist/graph/path/language/error.d.ts

@@ -7,4 +7,3 @@ export declare class PathError extends TypeError {
     constructor(input: unknown, diagnostics: readonly [PathDiagnostic, ...PathDiagnostic[]]);
 }
 export declare function pathError(input: unknown, code: PathDiagnosticCode, message: string, position?: number): PathError;
-//# sourceMappingURL=error.d.ts.map

package/dist/graph/path/language/error.js

@@ -19,4 +19,3 @@ export function pathError(input, code, message, position) {
         },
     ]);
 }
-//# sourceMappingURL=error.js.map

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

@@ -7,4 +7,3 @@ export { normalizePathAST, parsePathAST, serializePathAST } from './syntax.js';
 export declare function NodePath(input: string): NodePathValue;
 /** Return whether an unknown value is exact canonical V1 NodePath text. */
 export declare function isNodePath(input: unknown): input is NodePathValue;
-//# sourceMappingURL=index.d.ts.map

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

@@ -19,4 +19,3 @@ export function isNodePath(input) {
         throw error;
     }
 }
-//# sourceMappingURL=index.js.map

package/dist/graph/path/language/model.d.ts

@@ -25,11 +25,16 @@ export interface ProjectionStep {
     readonly kind: 'projection';
     readonly projection: DomainProjection;
 }
-export interface MethodStep {
+export type MethodStep = {
     readonly kind: 'method';
-    readonly dispatch: 'static' | 'instance';
+    readonly dispatch: 'static';
     readonly name: string;
-}
+} | {
+    readonly kind: 'method';
+    readonly dispatch: 'instance';
+    readonly class: ClassKey;
+    readonly name: string;
+};
 export interface TraversalStep {
     readonly kind: 'traverse';
     readonly direction: 'out' | 'in';
@@ -48,4 +53,3 @@ export interface PathDiagnostic {
     readonly message: string;
 }
 export {};
-//# sourceMappingURL=model.d.ts.map

package/dist/graph/path/language/model.js

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

package/dist/graph/path/language/syntax.d.ts

@@ -2,4 +2,3 @@ import type { NodePath, PathAST } from './model.js';
 export declare function parsePathAST(input: string): PathAST;
 export declare function normalizePathAST(input: unknown): PathAST;
 export declare function serializePathAST(input: PathAST): NodePath;
-//# sourceMappingURL=syntax.d.ts.map

package/dist/graph/path/language/syntax.js

@@ -1,4 +1,4 @@
-import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import { patterns, MethodKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { EdgeSlug, isEdgeSlug } from '../../edge/slug/index.js';
 import { isNodeId } from '../../node/identity/index.js';
@@ -34,7 +34,9 @@ export function normalizePathAST(input) {
             continue;
         }
         if (candidate.kind === 'method') {
-            if (!hasExactKeys(candidate, ['kind', 'dispatch', 'name']))
+            if (!hasExactKeys(candidate, candidate.dispatch === 'instance'
+                ? ['kind', 'dispatch', 'class', 'name']
+                : ['kind', 'dispatch', 'name']))
                 invalidAST();
             if (candidate.dispatch !== 'static' && candidate.dispatch !== 'instance')
                 invalidAST();
@@ -49,7 +51,18 @@ export function normalizePathAST(input) {
                     invalidAST();
                 }
             }
-            steps.push({ kind: 'method', dispatch: candidate.dispatch, name: candidate.name });
+            if (candidate.dispatch === 'instance') {
+                if (!ClassKey.is(candidate.class))
+                    invalidAST();
+                steps.push({
+                    kind: 'method',
+                    dispatch: 'instance',
+                    class: ClassKey(candidate.class),
+                    name: candidate.name,
+                });
+            }
+            else
+                steps.push({ kind: 'method', dispatch: 'static', name: candidate.name });
             continue;
         }
         if (candidate.kind === 'traverse') {
@@ -111,11 +124,12 @@ function parseSteps(input, start, anchorKind) {
     let cursor = start;
     while (cursor < input.length) {
         if (input.startsWith('::', cursor)) {
-            const name = input.slice(cursor + 2);
-            if (!patterns.memberName.test(name)) {
-                throw pathError(input, 'PATH_INVALID_METHOD', 'Invalid instance Method name.', cursor + 2);
+            const key = input.slice(cursor + 2);
+            if (!MethodKey.is(key)) {
+                throw pathError(input, 'PATH_INVALID_METHOD', 'Instance Method requires a complete domain-qualified Method key.', cursor + 2);
             }
-            steps.push({ kind: 'method', dispatch: 'instance', name });
+            const { owner, name } = MethodKey.address(key);
+            steps.push({ kind: 'method', dispatch: 'instance', class: ClassKey.of(owner), name });
             cursor = input.length;
             continue;
         }
@@ -234,7 +248,8 @@ function serializeNormalizedPathAST(ast) {
             output += `:${step.projection.kind}.${step.projection.name}`;
         }
         else if (step.kind === 'method') {
-            output += `${step.dispatch === 'instance' ? '::' : ':'}${step.name}`;
+            output +=
+                step.dispatch === 'instance' ? `::${step.class}.method.${step.name}` : `:${step.name}`;
         }
         else {
             output += `${step.direction === 'in' ? '<~' : '~'}"${step.class}"`;
@@ -286,4 +301,3 @@ function invalidClass(input, position) {
 function invalidEdgeSlug(input, position) {
     throw pathError(input, 'PATH_INVALID_EDGE_SLUG', 'Traversal Edge slug is invalid.', position);
 }
-//# sourceMappingURL=syntax.js.map

package/dist/graph/properties/condition/index.d.ts

@@ -36,4 +36,3 @@ export declare function isDesiredProperties(value: Properties | DesiredPropertie
 export declare function combine(left: DesiredProperties, right: DesiredProperties): DesiredPropertiesResult;
 export declare function createDesiredProperties(values: Properties, absent: readonly PropertyKeyValue[]): DesiredProperties;
 export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/properties/condition/index.js

@@ -119,4 +119,3 @@ function compare(left, right) {
 function child(pointer, suffix) {
     return `${pointer}/${suffix}`;
 }
-//# sourceMappingURL=index.js.map

package/dist/graph/properties/delta/index.d.ts

@@ -21,4 +21,3 @@ export declare function apply(current: Properties, delta: Delta): Properties;
 export declare function compose(first: Delta, second: Delta): Delta;
 export declare function createDelta(set: Properties, unset: readonly PropertyKeyValue[]): Delta;
 export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/properties/delta/index.js

@@ -101,4 +101,3 @@ function hasExactKeys(value, expected) {
 function child(pointer, suffix) {
     return `${pointer}/${suffix}`;
 }
-//# sourceMappingURL=index.js.map

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

@@ -12,4 +12,3 @@ export type { MergeConflict, MergeResult } from './merge/index.js';
 /** Compose complete-target and partial-condition Delta derivation behind the flat public facade. */
 export declare function delta(current: Properties, target: Properties): Delta | null;
 export declare function delta(current: Properties, desired: DesiredProperties): Delta | null;
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/properties/index.js

@@ -9,4 +9,3 @@ export function delta(current, target) {
         ? conditionDelta(current, target)
         : completeDelta(current, target);
 }
-//# sourceMappingURL=index.js.map

package/dist/graph/properties/merge/index.d.ts

@@ -11,4 +11,3 @@ export type MergeResult = {
     readonly conflicts: readonly MergeConflict[];
 };
 export declare function merge(base: Properties, current: Properties, target: Properties): MergeResult;
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/properties/merge/index.js

@@ -45,4 +45,3 @@ function equalState(left, right) {
 function compare(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
-//# sourceMappingURL=index.js.map

package/dist/graph/properties/value/index.d.ts

@@ -10,4 +10,3 @@ export declare const normalizeProperties: (input: unknown, pointer?: string) =>
 export declare const createProperties: (entries: Iterable<readonly [PropertyKey, Value]>) => Properties;
 /** Compare complete Property maps by canonical portable-value meaning. */
 export declare function equal(left: Properties, right: Properties): boolean;
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/properties/value/index.js

@@ -12,4 +12,3 @@ export function equal(left, right) {
     return (leftKeys.length === rightKeys.length &&
         leftKeys.every((key, index) => key === rightKeys[index] && equalValue(left[key], right[key])));
 }
-//# sourceMappingURL=index.js.map

package/dist/graph/query/authoring/builder.d.ts

@@ -61,4 +61,3 @@ export declare function Property(input: PropertyKeyValue): QueryPropertyPredicat
 /** Primary persistent Query V6 authoring entry point. */
 export declare const Query: QueryAPI;
 export {};
-//# sourceMappingURL=builder.d.ts.map

package/dist/graph/query/authoring/builder.js

@@ -1,6 +1,5 @@
-import { PropertyKey, } from '@astrale-os/kernel-dsl/v1/addressing';
+import { ClassKey, PropertyKey, } from '@astrale-os/kernel-dsl/v1/addressing';
 import * as portable from '@astrale-os/kernel-dsl/value';
-import { isNodeId } from '../../node/index.js';
 import { Path } from '../../path/index.js';
 import { QueryAST as QueryASTBoundary, QueryASTDecodeError } from '../language/index.js';
 function from(input) {
@@ -41,6 +40,33 @@ export function Property(input) {
         isPresent() {
             return Object.freeze({ kind: 'property.present', property: key });
         },
+        greater: (value) => range(key, bound(value, false, 'lower'), undefined),
+        greaterOrEqual: (value) => range(key, bound(value, true, 'lower'), undefined),
+        less: (value) => range(key, undefined, bound(value, false, 'upper')),
+        lessOrEqual: (value) => range(key, undefined, bound(value, true, 'upper')),
+        between(lower, upper, bounds = {}) {
+            if (typeof lower !== typeof upper) {
+                invalid('/predicate/upper/value', 'Range bounds must have one kind');
+            }
+            return range(key, bound(lower, bounds.lower !== 'exclusive', 'lower'), bound(upper, bounds.upper !== 'exclusive', 'upper'));
+        },
+    });
+}
+function bound(value, inclusive, side) {
+    if (typeof value !== 'number' && typeof value !== 'string') {
+        invalid(`/predicate/${side}/value`, 'Range bound must be a number or a text');
+    }
+    return Object.freeze({
+        value: canonicalValue(value, `/predicate/${side}/value`),
+        inclusive,
+    });
+}
+function range(property, lower, upper) {
+    return Object.freeze({
+        kind: 'property.range',
+        property,
+        ...(lower === undefined ? {} : { lower }),
+        ...(upper === undefined ? {} : { upper }),
     });
 }
 /** Primary persistent Query V6 authoring entry point. */
@@ -191,12 +217,12 @@ function appendFilter(state, input, defaultBinding) {
         ...(state.edge === undefined ? {} : { edge: state.edge }),
     });
 }
-function canonicalValue(input) {
+function canonicalValue(input, path = '/predicate/value') {
     try {
         return freezeValue(portable.json.decode(portable.json.encode(input)));
     }
     catch (cause) {
-        invalid('/predicate/value', 'Invalid portable equality value', cause);
+        invalid(path, 'Invalid portable Property value', cause);
     }
 }
 function freezeValue(input) {
@@ -370,9 +396,18 @@ function requiredArray(input, path, label) {
 }
 function lowerNodeSource(input, index) {
     const path = `/source/nodes/${index}`;
-    if (input instanceof Path || typeof input === 'string') {
+    if (ClassKey.is(input)) {
+        return Object.freeze({ kind: 'class', class: ClassKey.ref(input) });
+    }
+    if (input instanceof Path ||
+        typeof input === 'string' ||
+        (isRecord(input) &&
+            (input.kind === 'core' ||
+                input.kind === 'function' ||
+                input.kind === 'policy' ||
+                input.kind === 'view'))) {
         try {
-            const target = input instanceof Path ? input : isNodeId(input) ? Path.id(input) : Path.parse(input);
+            const target = Path.target(input);
             return Object.freeze({ kind: 'path', path: target.raw });
         }
         catch (cause) {
@@ -382,6 +417,8 @@ function lowerNodeSource(input, index) {
     return Object.freeze({ kind: 'class', class: normalizeClass(input, 'node', path) });
 }
 function normalizeClass(input, expectedKind, path) {
+    if (ClassKey.is(input))
+        return ClassKey.ref(input);
     if (!isRecord(input))
         invalid(path, 'Class input must be an object');
     const candidate = Object.hasOwn(input, 'ref') ? input.ref : input;
@@ -414,4 +451,3 @@ function escapeToken(input) {
 function invalid(path, message, cause) {
     throw new QueryASTDecodeError(path, message, cause === undefined ? undefined : { cause });
 }
-//# sourceMappingURL=builder.js.map