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

package/dist/graph/query/language/wire.js

@@ -1,68 +1,75 @@
-import { z } from 'zod';
+import { array, boolean, discriminatedUnion, enum as enumeration, literal, number, strictObject, string, union, unknown as unknownSchema, } from 'zod';
 import { QUERY_AST_FORMAT, QUERY_AST_LIMITS, QUERY_AST_VERSION } from './model.js';
-const text = z.string().min(1);
+const text = string().min(1);
 const binding = text.max(64);
-const classRef = z.strictObject({
+const classRef = strictObject({
     origin: text.max(253),
-    kind: z.literal('class'),
+    kind: literal('class'),
     name: text,
 });
-const nodeSourceTerm = z.discriminatedUnion('kind', [
-    z.strictObject({ kind: z.literal('path'), path: text }),
-    z.strictObject({ kind: z.literal('class'), class: classRef }),
+const nodeSourceTerm = discriminatedUnion('kind', [
+    strictObject({ kind: literal('path'), path: text }),
+    strictObject({ kind: literal('class'), class: classRef }),
 ]);
-const classSourceTerm = z.strictObject({ kind: z.literal('class'), class: classRef });
-const source = z.discriminatedUnion('kind', [
-    z.strictObject({
-        kind: z.literal('node'),
-        terms: z.array(nodeSourceTerm).min(1).max(QUERY_AST_LIMITS.sourceTerms),
+const classSourceTerm = strictObject({ kind: literal('class'), class: classRef });
+const source = discriminatedUnion('kind', [
+    strictObject({
+        kind: literal('node'),
+        terms: array(nodeSourceTerm).min(1).max(QUERY_AST_LIMITS.sourceTerms),
         binding,
     }),
-    z.strictObject({
-        kind: z.literal('edge'),
-        terms: z.array(classSourceTerm).min(1).max(QUERY_AST_LIMITS.sourceTerms),
-        bindings: z.strictObject({ source: binding, edge: binding, target: binding }),
+    strictObject({
+        kind: literal('edge'),
+        terms: array(classSourceTerm).min(1).max(QUERY_AST_LIMITS.sourceTerms),
+        bindings: strictObject({ source: binding, edge: binding, target: binding }),
     }),
 ]);
-const predicate = z.discriminatedUnion('kind', [
-    z.strictObject({ kind: z.literal('class.satisfies'), class: classRef }),
-    z.strictObject({ kind: z.literal('class.equal'), class: classRef }),
-    z.strictObject({ kind: z.literal('property.equal'), property: text, value: z.unknown() }),
-    z.strictObject({ kind: z.literal('property.present'), property: text }),
-    z.strictObject({
-        kind: z.literal('identity.equal'),
-        identity: z.union([text, z.strictObject({ source: text, target: text, class: text })]),
+const rangeBound = strictObject({ value: union([number(), string()]), inclusive: boolean() });
+const predicate = discriminatedUnion('kind', [
+    strictObject({ kind: literal('class.satisfies'), class: classRef }),
+    strictObject({ kind: literal('class.equal'), class: classRef }),
+    strictObject({ kind: literal('property.equal'), property: text, value: unknownSchema() }),
+    strictObject({ kind: literal('property.present'), property: text }),
+    strictObject({
+        kind: literal('property.range'),
+        property: text,
+        lower: rangeBound.optional(),
+        upper: rangeBound.optional(),
+    }),
+    strictObject({
+        kind: literal('identity.equal'),
+        identity: union([text, strictObject({ source: text, target: text, class: text })]),
     }),
 ]);
-const filter = z.strictObject({ op: z.literal('filter'), binding, predicate });
-const expand = z.strictObject({
-    op: z.literal('expand'),
+const filter = strictObject({ op: literal('filter'), binding, predicate });
+const expand = strictObject({
+    op: literal('expand'),
     from: binding,
-    via: z.array(classRef).min(1).max(QUERY_AST_LIMITS.expansionClassesPerStep),
-    direction: z.enum(['outgoing', 'incoming', 'incident']),
-    bindings: z.strictObject({ edge: binding, node: binding }),
+    via: array(classRef).min(1).max(QUERY_AST_LIMITS.expansionClassesPerStep),
+    direction: enumeration(['outgoing', 'incoming', 'incident']),
+    bindings: strictObject({ edge: binding, node: binding }),
 });
-const propertyOrder = z.strictObject({
+const propertyOrder = strictObject({
     property: text,
-    direction: z.enum(['asc', 'desc']),
-    unranked: z.enum(['first', 'last']),
+    direction: enumeration(['asc', 'desc']),
+    unranked: enumeration(['first', 'last']),
 });
-const projectionShape = z.enum(['reference', 'value']);
-const graphSelect = z.strictObject({
-    kind: z.literal('graph'),
+const projectionShape = enumeration(['reference', 'value']);
+const graphSelect = strictObject({
+    kind: literal('graph'),
     binding,
     order: propertyOrder.optional(),
 });
-const nodeSelect = z.strictObject({
-    kind: z.literal('nodes'),
+const nodeSelect = strictObject({
+    kind: literal('nodes'),
     binding,
-    projection: z.strictObject({ kind: projectionShape }),
+    projection: strictObject({ kind: projectionShape }),
     order: propertyOrder.optional(),
 });
-const edgeSelect = z.strictObject({
-    kind: z.literal('edges'),
+const edgeSelect = strictObject({
+    kind: literal('edges'),
     binding,
-    projection: z.strictObject({
+    projection: strictObject({
         edge: projectionShape,
         source: projectionShape,
         target: projectionShape,
@@ -70,11 +77,10 @@ const edgeSelect = z.strictObject({
     order: propertyOrder.optional(),
 });
 /** Structural JSON contract; decodeQueryAST owns canonical identities and binding dependencies. */
-export const queryAstSchema = z.strictObject({
-    format: z.literal(QUERY_AST_FORMAT),
-    version: z.literal(QUERY_AST_VERSION),
+export const queryAstSchema = strictObject({
+    format: literal(QUERY_AST_FORMAT),
+    version: literal(QUERY_AST_VERSION),
     source,
-    steps: z.array(z.discriminatedUnion('op', [filter, expand])).max(QUERY_AST_LIMITS.steps),
-    select: z.discriminatedUnion('kind', [graphSelect, nodeSelect, edgeSelect]),
+    steps: array(discriminatedUnion('op', [filter, expand])).max(QUERY_AST_LIMITS.steps),
+    select: discriminatedUnion('kind', [graphSelect, nodeSelect, edgeSelect]),
 });
-//# sourceMappingURL=wire.js.map

package/dist/graph/query/order/index.d.ts

@@ -0,0 +1,53 @@
+import type { OrderingKind } from '@astrale-os/kernel-dsl/v1/language';
+import type * as portable from '@astrale-os/kernel-dsl/value';
+import type { EdgeKey } from '../../edge/index.js';
+import type { NodeId } from '../../node/index.js';
+import type { QueryOrderDirection, QueryPropertyRangePredicate, QueryUnrankedPlacement } from '../language/index.js';
+/** The identity of one selected fact: a Node's NodeId or an Edge's complete EdgeKey. */
+export type QueryRankIdentity = NodeId | EdgeKey;
+/** A scalar ordering value of one proven kind; an instant is its canonical text. */
+export type QueryRankValue = boolean | number | string;
+/** One selected fact's position: its bucket, its ordering value when ranked, and its identity. */
+export type QueryRank<Identity extends QueryRankIdentity = QueryRankIdentity> = {
+    readonly bucket: 'identity';
+    readonly identity: Identity;
+} | {
+    readonly bucket: 'ranked';
+    readonly value: QueryRankValue;
+    readonly identity: Identity;
+} | {
+    readonly bucket: 'unranked';
+    readonly identity: Identity;
+};
+/** The ordering of one Property order: its proven value kind, direction and unranked placement. */
+export interface QueryRankOrder {
+    readonly kind: OrderingKind;
+    readonly direction: QueryOrderDirection;
+    readonly unranked: QueryUnrankedPlacement;
+}
+/**
+ * The one observable Query order. Without a Property order, facts follow identity order. With one,
+ * unranked facts sit first or last regardless of direction, ranked values compare by their kind in
+ * the requested direction, and identity breaks every tie: NodeId byte order, or EdgeKey order by
+ * source, target and ClassKey.
+ */
+export declare function compareQueryRank(left: QueryRank, right: QueryRank, order: QueryRankOrder | undefined): number;
+/**
+ * Compare two ordering values of one kind: false before true, numeric order, and code-point order
+ * for strings and instants.
+ */
+export declare function compareQueryValue(left: QueryRankValue, right: QueryRankValue, kind: OrderingKind): number;
+/**
+ * Unicode code-point order, which equals the byte order of the UTF-8 encodings. UTF-16 unit order
+ * differs from it only where a surrogate meets a unit at or above U+E000; the fixup reorders
+ * exactly that range.
+ */
+export declare function compareQueryText(left: string, right: string): number;
+/**
+ * Whether one stored value lies in a Property range: it has the kind of the bounds, a number in
+ * numeric order or a text in code-point order, and every present bound holds. A value of any other
+ * kind, an absent value included, is never in the range; this is never an error.
+ */
+export declare function queryRangeContains(range: Pick<QueryPropertyRangePredicate, 'lower' | 'upper'>, value: portable.Value | undefined): boolean;
+/** Identity order: NodeId byte order, or EdgeKey (source, target, ClassKey) tuple order. */
+export declare function compareQueryIdentity(left: QueryRankIdentity, right: QueryRankIdentity): number;

package/dist/graph/query/order/index.js

@@ -0,0 +1,79 @@
+import { compareEdgeKeys } from '../../edge/index.js';
+import { compareNodeIds } from '../../node/index.js';
+/**
+ * The one observable Query order. Without a Property order, facts follow identity order. With one,
+ * unranked facts sit first or last regardless of direction, ranked values compare by their kind in
+ * the requested direction, and identity breaks every tie: NodeId byte order, or EdgeKey order by
+ * source, target and ClassKey.
+ */
+export function compareQueryRank(left, right, order) {
+    if (order !== undefined && left.bucket !== right.bucket) {
+        const first = order.unranked === 'first' ? 'unranked' : 'ranked';
+        return left.bucket === first ? -1 : 1;
+    }
+    if (order !== undefined && left.bucket === 'ranked' && right.bucket === 'ranked') {
+        const compared = compareQueryValue(left.value, right.value, order.kind);
+        if (compared !== 0)
+            return order.direction === 'asc' ? compared : -compared;
+    }
+    return compareQueryIdentity(left.identity, right.identity);
+}
+/**
+ * Compare two ordering values of one kind: false before true, numeric order, and code-point order
+ * for strings and instants.
+ */
+export function compareQueryValue(left, right, kind) {
+    if (kind === 'boolean')
+        return Number(left) - Number(right);
+    if (kind === 'number')
+        return Math.sign(left - right);
+    return compareQueryText(left, right);
+}
+/**
+ * Unicode code-point order, which equals the byte order of the UTF-8 encodings. UTF-16 unit order
+ * differs from it only where a surrogate meets a unit at or above U+E000; the fixup reorders
+ * exactly that range.
+ */
+export function compareQueryText(left, right) {
+    const length = Math.min(left.length, right.length);
+    for (let index = 0; index < length; index++) {
+        let a = left.charCodeAt(index);
+        let b = right.charCodeAt(index);
+        if (a === b)
+            continue;
+        if (a >= 0xd800 && b >= 0xd800) {
+            a += a >= 0xe000 ? -0x800 : 0x2000;
+            b += b >= 0xe000 ? -0x800 : 0x2000;
+        }
+        return a < b ? -1 : 1;
+    }
+    return Math.sign(left.length - right.length);
+}
+/**
+ * Whether one stored value lies in a Property range: it has the kind of the bounds, a number in
+ * numeric order or a text in code-point order, and every present bound holds. A value of any other
+ * kind, an absent value included, is never in the range; this is never an error.
+ */
+export function queryRangeContains(range, value) {
+    const kind = (range.lower ?? range.upper)?.value;
+    if (typeof value !== typeof kind || (typeof value !== 'number' && typeof value !== 'string')) {
+        return false;
+    }
+    const holds = (bound, sign) => {
+        if (bound === undefined)
+            return true;
+        const compared = typeof value === 'number'
+            ? Math.sign(value - bound.value)
+            : compareQueryText(value, bound.value);
+        return compared === 0 ? bound.inclusive : compared === sign;
+    };
+    return holds(range.lower, 1) && holds(range.upper, -1);
+}
+/** Identity order: NodeId byte order, or EdgeKey (source, target, ClassKey) tuple order. */
+export function compareQueryIdentity(left, right) {
+    if (typeof left === 'string' && typeof right === 'string')
+        return compareNodeIds(left, right);
+    if (typeof left !== 'string' && typeof right !== 'string')
+        return compareEdgeKeys(left, right);
+    throw new TypeError('Query rank identities of different kinds are not comparable.');
+}

package/dist/graph/query/reference/error.d.ts

@@ -3,4 +3,3 @@ export declare class QueryReferenceError extends TypeError {
     readonly code: 'QUERY_REFERENCE_INVALID';
     constructor(path: string, message: string, options?: ErrorOptions);
 }
-//# sourceMappingURL=error.d.ts.map

package/dist/graph/query/reference/error.js

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

package/dist/graph/query/reference/evaluate.d.ts

@@ -29,6 +29,7 @@ export interface QueryReferenceContext {
     closeClass(classRef: ClassRef): QueryReferenceClassClosure | undefined;
     closeProperty(property: PropertyKeyValue): QueryReferenceProperty | undefined;
     orientation(edge: ClassKey): EdgeOrientation | undefined;
+    admitEdge(edge: Edge, source: Node, target: Node): boolean;
     traverseNode(node: Node): boolean;
     traverseEdge(edge: Edge): boolean;
     readNode(node: Node): boolean;
@@ -67,4 +68,3 @@ export interface QueryReferenceTrace {
 export declare const QueryReference: {
     evaluate(input: QueryAST, context: QueryReferenceContext, options: QueryReferenceOptions): QueryReferenceEvaluation;
 };
-//# sourceMappingURL=evaluate.d.ts.map

package/dist/graph/query/reference/evaluate.js

@@ -6,6 +6,7 @@ import { GraphData } from '../../graph/index.js';
 import { NodeId as admitNodeId } from '../../node/index.js';
 import { compareNodeIds } from '../../node/index.js';
 import { encodeQueryAST, QueryASTDecodeError } from '../language/index.js';
+import { compareQueryRank, queryRangeContains } from '../order/index.js';
 import { decodeQueryResult } from '../result/index.js';
 import { QueryReferenceError } from './error.js';
 /** Independent backend-neutral executable Query V6 row algebra. */
@@ -141,8 +142,10 @@ function evaluate(ast, context, options) {
                     if (!Object.hasOwn(value.value.props, predicate.property)) {
                         return false;
                     }
-                    return (predicate.kind === 'property.present' ||
-                        portable.equal(value.value.props[predicate.property], predicate.value));
+                    const stored = value.value.props[predicate.property];
+                    if (predicate.kind === 'property.range')
+                        return queryRangeContains(predicate, stored);
+                    return predicate.kind === 'property.present' || portable.equal(stored, predicate.value);
                 });
             }
             stepRows.push(rows.length);
@@ -273,9 +276,13 @@ function decodeWitness(input, path, context) {
 }
 function selectNodes(rows, select, size, after, admission, properties) {
     const selected = new Map();
+    const ordered = orderedClasses(select.order, 'node', properties);
     rows.forEach((row) => {
         const node = boundNode(row, select.binding, '/select/binding');
-        const needsRead = select.kind === 'graph' || (select.kind === 'nodes' && select.projection.kind === 'value');
+        // A value is read; an ordered reference reads a fact its order applies to before ranking it.
+        const needsRead = select.kind === 'graph' ||
+            (select.kind === 'nodes' && select.projection.kind === 'value') ||
+            ordered.has(node.class);
         if (needsRead && !admission.readNode(node, '/select/binding'))
             return;
         selected.set(node.id, node);
@@ -305,6 +312,7 @@ function selectNodes(rows, select, size, after, admission, properties) {
 }
 function selectEdges(rows, select, size, after, context, admission, properties) {
     const selected = new Map();
+    const ordered = orderedClasses(select.order, 'edge', properties);
     rows.forEach((row) => {
         const edge = boundEdge(row, select.binding, '/select/binding');
         const source = requireNode(context, edge.source, '/select/binding');
@@ -319,7 +327,7 @@ function selectEdges(rows, select, size, after, context, admission, properties)
                 admission.readNode(source, '/select/binding') &&
                 admission.readNode(target, '/select/binding')
             : select.kind === 'edges'
-                ? (select.projection.edge === 'reference' ||
+                ? ((select.projection.edge === 'reference' && !ordered.has(edge.class)) ||
                     admission.readEdge(edge, '/select/binding')) &&
                     (select.projection.source === 'reference' ||
                         admission.readNode(source, '/select/binding')) &&
@@ -362,12 +370,24 @@ function selectEdges(rows, select, size, after, context, admission, properties)
     const next = last === undefined ? undefined : frontierOf(last, order, 'edge', properties);
     return Object.freeze({ result, ...(next === undefined ? {} : { next }) });
 }
+/** The Classes a Property order applies to, whose facts are read before they are ranked. */
+function orderedClasses(order, kind, properties) {
+    return order === undefined
+        ? new Set()
+        : properties.close(order.property, kind, '/select/order/property');
+}
 function orderingComparator(order, kind, properties) {
-    return (left, right) => compareReferenceRank(rankOf(left, order, kind, properties), rankOf(right, order, kind, properties), order);
+    const ordering = orderingOf(order, kind, properties);
+    return (left, right) => compareReferenceRank(rankOf(left, order, kind, properties), rankOf(right, order, kind, properties), order, ordering);
+}
+function orderingOf(order, kind, properties) {
+    return order === undefined
+        ? undefined
+        : properties.ordering(order.property, kind, '/select/order/property');
 }
 function compareFrontier(frontier, fact, order, kind, properties) {
     const admitted = decodeReferenceFrontier(frontier, order, kind, properties);
-    return compareReferenceRank(admitted, rankOf(fact, order, kind, properties), order);
+    return compareReferenceRank(admitted, rankOf(fact, order, kind, properties), order, orderingOf(order, kind, properties));
 }
 function frontierOf(fact, order, kind, properties) {
     const rank = rankOf(fact, order, kind, properties);
@@ -413,36 +433,8 @@ function decodeReferenceFrontier(frontier, order, kind, properties) {
     }
     return Object.freeze({ bucket: 'ranked', value: frontier.value, identity });
 }
-function compareReferenceRank(left, right, order) {
-    if (order === undefined)
-        return compareIdentity(left.identity, right.identity);
-    if (left.bucket !== right.bucket) {
-        return left.bucket === 'unranked'
-            ? order.unranked === 'first'
-                ? -1
-                : 1
-            : order.unranked === 'first'
-                ? 1
-                : -1;
-    }
-    if (left.bucket === 'ranked' && right.bucket === 'ranked') {
-        const kind = typeof left.value === 'boolean'
-            ? 'boolean'
-            : typeof left.value === 'number'
-                ? 'number'
-                : 'string';
-        const compared = compareOrderingValue(left.value, right.value, kind);
-        if (compared !== 0)
-            return order.direction === 'asc' ? compared : -compared;
-    }
-    return compareIdentity(left.identity, right.identity);
-}
-function compareIdentity(left, right) {
-    if (typeof left === 'string' && typeof right === 'string')
-        return compareNodeIds(left, right);
-    if (typeof left !== 'string' && typeof right !== 'string')
-        return compareEdgeKeys(left, right);
-    invalid('/after/identity', 'Frontier identity kind disagrees with selection');
+function compareReferenceRank(left, right, order, ordering) {
+    return compareQueryRank(left, right, order === undefined || ordering === undefined ? undefined : { ...order, kind: ordering });
 }
 function orderingValue(input, kind) {
     if (kind === 'boolean')
@@ -451,22 +443,6 @@ function orderingValue(input, kind) {
         return typeof input === 'number' && Number.isFinite(input);
     return typeof input === 'string';
 }
-function compareOrderingValue(left, right, kind) {
-    if (kind === 'boolean')
-        return Number(left) - Number(right);
-    if (kind === 'number')
-        return left - right;
-    return compareUnicodeScalars(left, right);
-}
-function compareUnicodeScalars(left, right) {
-    const a = Array.from(left, (value) => value.codePointAt(0));
-    const b = Array.from(right, (value) => value.codePointAt(0));
-    for (let index = 0; index < Math.min(a.length, b.length); index += 1) {
-        if (a[index] !== b[index])
-            return a[index] - b[index];
-    }
-    return a.length - b.length;
-}
 function projectNode(node, shape) {
     return shape === 'value'
         ? Object.freeze({ kind: 'value', value: node })
@@ -611,6 +587,15 @@ class Admission {
         const cached = this.#edges.get(key);
         if (cached !== undefined)
             return cached;
+        const source = requireNode(this.context, edge.source, path);
+        const target = requireNode(this.context, edge.target, path);
+        const admitted = call(path, 'Logical Edge fact admission failed', () => this.context.admitEdge(edge, source, target));
+        if (typeof admitted !== 'boolean')
+            invalid(path, 'Logical Edge fact admission must return boolean');
+        if (!admitted) {
+            this.#edges.set(key, false);
+            return false;
+        }
         const explicit = call(path, 'Edge traversal admission failed', () => this.context.traverseEdge(edge));
         if (typeof explicit !== 'boolean')
             invalid(path, 'Edge traversal admission must return boolean');
@@ -648,6 +633,7 @@ function acceptContext(input) {
         'closeClass',
         'closeProperty',
         'orientation',
+        'admitEdge',
         'traverseNode',
         'traverseEdge',
         'readNode',
@@ -671,6 +657,7 @@ function acceptContext(input) {
         closeClass: input.closeClass.bind(input),
         closeProperty: input.closeProperty.bind(input),
         orientation: input.orientation.bind(input),
+        admitEdge: input.admitEdge.bind(input),
         traverseNode: input.traverseNode.bind(input),
         traverseEdge: input.traverseEdge.bind(input),
         readNode: input.readNode.bind(input),
@@ -743,4 +730,3 @@ function isRecord(input) {
 function invalid(path, message, cause) {
     throw new QueryReferenceError(path, message, cause === undefined ? undefined : { cause });
 }
-//# sourceMappingURL=evaluate.js.map

package/dist/graph/query/reference/index.d.ts

@@ -1,4 +1,3 @@
 export { QueryReference } from './evaluate.js';
 export type { QueryReferenceContext, QueryReferenceClassClosure, QueryReferenceEvaluation, QueryReferenceFrontier, QueryReferenceIdentity, QueryReferenceOptions, QueryReferencePathWitness, QueryReferenceProperty, QueryReferenceTrace, } from './evaluate.js';
 export { QueryReferenceError } from './error.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/query/reference/index.js

@@ -1,3 +1,2 @@
 export { QueryReference } from './evaluate.js';
 export { QueryReferenceError } from './error.js';
-//# sourceMappingURL=index.js.map

package/dist/graph/query/result/error.d.ts

@@ -3,4 +3,3 @@ export declare class QueryResultDecodeError extends TypeError {
     readonly code: 'QUERY_RESULT_INVALID';
     constructor(path: string, message: string, options?: ErrorOptions);
 }
-//# sourceMappingURL=error.d.ts.map

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

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

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

@@ -89,4 +89,3 @@ export declare function encodeQueryResult(input: QueryResult): QueryResult;
 export declare function queryResultSelection<Result extends QueryResult>(input: Result): QuerySelectionFor<Result>;
 /** Decode exact QueryResult structure; Query-relative closure remains Runtime-owned. */
 export declare function decodeQueryResult(input: unknown): QueryResult;
-//# sourceMappingURL=index.d.ts.map

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

@@ -35,7 +35,7 @@ export function queryResultSelection(input) {
 /** Decode exact QueryResult structure; Query-relative closure remains Runtime-owned. */
 export function decodeQueryResult(input) {
     try {
-        const value = decodeWire(queryResultSchema, portable.accept(input), invalid);
+        const value = decodeWire(queryResultSchema, portable.acceptForRead(input), invalid);
         if (value.kind === 'graph') {
             const graph = decodeGraph(value.graph, '/graph');
             const selection = decodeSelection(value.selection, graph);
@@ -173,4 +173,3 @@ function joinPointer(base, nested) {
 function errorPointer(error) {
     return error instanceof portable.BoundaryError ? error.pointer : '';
 }
-//# sourceMappingURL=index.js.map