@astrale-os/kernel-client 0.6.0-beta.5 → 0.6.0-beta.50

package/dist/graph/domain/domain.typecheck.js

@@ -0,0 +1,146 @@
+import { NodeId } from '@astrale-os/kernel-core/graph/node';
+import { Query, QueryAST } from '@astrale-os/kernel-core/graph/query';
+import { Path } from '@astrale-os/kernel-core/path';
+import { schema } from '@astrale-os/kernel-dsl/v1';
+import { defineSchema, edgeClass, method, nodeClass, property, valueSchema, } from '@astrale-os/kernel-dsl/v1/builder';
+const Resource = nodeClass({
+    abstract: true,
+    properties: {
+        title: property(valueSchema()({ type: 'string' }), { required: true }),
+    },
+    methods: {
+        rename: method({
+            auth: 'authenticated',
+            input: valueSchema()({
+                type: 'object',
+                properties: { title: { type: 'string' } },
+                required: ['title'],
+                additionalProperties: false,
+            }),
+            output: valueSchema()({ type: 'string' }),
+        }),
+    },
+});
+const Document = nodeClass({
+    extends: [Resource],
+    properties: { body: property(valueSchema()({ type: 'string' })) },
+});
+const MethodlessParent = nodeClass({
+    abstract: true,
+    properties: {},
+});
+const MethodlessChild = nodeClass({
+    extends: [MethodlessParent],
+    properties: {},
+});
+const PrototypeMembers = nodeClass({
+    properties: {
+        toString: property(valueSchema()({ type: 'string' }), { required: true }),
+    },
+    methods: {
+        constructor: method({
+            auth: 'authenticated',
+            input: valueSchema()({ type: 'string' }),
+            output: valueSchema()({ type: 'string' }),
+        }),
+    },
+});
+const Work = schema.resolve(defineSchema('client-binding-types.example', {
+    classes: {
+        Resource,
+        Document,
+        MethodlessParent,
+        MethodlessChild,
+        PrototypeMembers,
+        Related: edgeClass.directed({
+            source: { as: 'source', accepts: [Resource], outgoing: '0..*' },
+            target: { as: 'target', accepts: [Resource], incoming: '0..*' },
+        }),
+    },
+}));
+const source = Query.from({ nodes: [Work.classes.Resource] });
+const query = source.select({ kind: 'nodes', projection: { kind: 'value' } });
+const prototypeSource = Query.from({ nodes: [Work.classes.PrototypeMembers] });
+const prototypeQuery = prototypeSource.select({ kind: 'nodes', projection: { kind: 'value' } });
+const resourceAcceptsDocument = documentProjection;
+void resourceAcceptsDocument;
+const resourceReceiverAcceptsDocument = documentProjection;
+void resourceReceiverAcceptsDocument;
+// @ts-expect-error A projection selected for another unrelated Class is not a Resource projection.
+const resourceRejectsPrototype = prototypeProjection;
+void resourceRejectsPrototype;
+// @ts-expect-error Receiver evidence selected for an unrelated Class is not accepted.
+const resourceReceiverRejectsPrototype = prototypeProjection;
+void resourceReceiverRejectsPrototype;
+const methodlessParentAcceptsChild = methodlessChildProjection;
+void methodlessParentAcceptsChild;
+// @ts-expect-error Selected ancestor provenance cannot be widened into a child projection.
+const documentRejectsResource = resourceProjection;
+void documentRejectsResource;
+async function typeProof() {
+    await graph.get(definitionRef);
+    await graph.getOrThrow(definitionRef);
+    await graph.get(Work.classes.Resource.ref);
+    await graph.neighbors(definitionRef, Work.classes.Related.ref, {
+        direction: 'outgoing',
+        page: { size: 1 },
+    });
+    const page = await binding.query(query, { page: { size: 10 } });
+    const resource = page.nodes[0];
+    const title = resource.title;
+    const renamed = await resource.rename({ title: 'next' });
+    // @ts-expect-error Ancestor projection does not expose child-only Properties.
+    resource.body;
+    const document = page.refine(resource, Work.classes.Document);
+    const body = document?.body;
+    const detached = QueryAST.decode(query);
+    // @ts-expect-error Decoding destroys the authoring Class provenance required for rich projection.
+    await binding.query(detached, { page: { size: 10 } });
+    const multipleClasses = Query.from({
+        nodes: [Work.classes.Resource, Work.classes.Document],
+    }).select({ kind: 'nodes', projection: { kind: 'value' } });
+    // @ts-expect-error Multiple Class terms do not establish one rich selected-Class contract.
+    await binding.query(multipleClasses, { page: { size: 10 } });
+    const mixedSource = Query.from({
+        nodes: [NodeId('document'), Work.classes.Resource],
+    }).select({ kind: 'nodes', projection: { kind: 'value' } });
+    // @ts-expect-error Path and Class terms do not establish one rich selected-Class contract.
+    await binding.query(mixedSource, { page: { size: 10 } });
+    const detachedRefSource = Query.from({ nodes: [Work.classes.Resource.ref] }).select({
+        kind: 'nodes',
+        projection: { kind: 'value' },
+    });
+    // @ts-expect-error A ClassRef has no resolved schema witness for rich projection.
+    await binding.query(detachedRefSource, { page: { size: 10 } });
+    const detachedKeySource = Query.from({ nodes: [Work.classes.Resource.key] }).select({
+        kind: 'nodes',
+        projection: { kind: 'value' },
+    });
+    // @ts-expect-error A ClassKey has no resolved schema witness for rich projection.
+    await binding.query(detachedKeySource, { page: { size: 10 } });
+    const prototypePage = await binding.query(prototypeQuery, { page: { size: 1 } });
+    const prototype = prototypePage.nodes[0];
+    const toString = prototype.toString;
+    const constructed = await prototype.constructor('input');
+    const structural = Path.project(Work.classes.Resource.ref).raw;
+    await graph.get(structural);
+    await graph.getOrThrow(structural);
+    await graph.neighbors(structural, Work.classes.Related, {
+        direction: 'outgoing',
+        page: { size: 1 },
+    });
+    const exact = NodeId('document');
+    await graph.get(exact);
+    await graph.getOrThrow(exact);
+    await graph.neighbors(exact, Work.classes.Related, {
+        direction: 'outgoing',
+        page: { size: 1 },
+    });
+    // @ts-expect-error Neighbor traversal requires Edge Classes, not Node Classes.
+    await graph.neighbors(exact, Work.classes.Resource, {
+        direction: 'outgoing',
+        page: { size: 1 },
+    });
+    return { title, renamed, body, toString, constructed };
+}
+void typeProof;

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

@@ -0,0 +1,3 @@
+export type { DomainBinding, DomainQueryOptions } from './binding.js';
+export type { BoundEdge, BoundGraphValue, BoundNode, BoundNodeFor } from './model.js';
+export type { BoundEdgePage, BoundNodePage, BoundQueryPage } from './page.js';

package/dist/graph/domain/index.js

@@ -0,0 +1 @@
+export {};

package/dist/graph/domain/model.d.ts

@@ -0,0 +1,18 @@
+import type { Edge } from '@astrale-os/kernel-core/graph/edge';
+import type { Node } from '@astrale-os/kernel-core/graph/node';
+import type { DefinitionKey, Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { AnyResolvedClass, BoundMethodShortcutsOf, ClassSatisfactionKeysOf, MethodAccessOf, PropertyAccessOf, PropertyShortcutsOf, ResolvedClass } from '@astrale-os/kernel-dsl/v1/language';
+import type { Binary } from '../../client/index.js';
+type NodeReserved = keyof Node | 'property' | 'method';
+type EdgeReserved = keyof Edge | 'property';
+declare const BOUND_CLASS: unique symbol;
+/** Node evidence selected as one exact Class key, without duplicating its rich projection. */
+export type BoundNodeFor<ClassKey extends DefinitionKey<Key.Origin, 'class'> = DefinitionKey<Key.Origin, 'class'>> = Node & {
+    readonly [BOUND_CLASS]: Readonly<Record<ClassKey, true>>;
+};
+/** One selected-Class view over an exact admitted Node. */
+export type BoundNode<Class extends ResolvedClass<'node'> = ResolvedClass<'node'>, BinaryValue = Binary> = BoundNodeFor<ClassSatisfactionKeysOf<Class>> & PropertyShortcutsOf<Class, NodeReserved> & BoundMethodShortcutsOf<Class, BinaryValue, NodeReserved> & PropertyAccessOf<Class> & MethodAccessOf<Class, BinaryValue>;
+/** One selected-Class view over an exact admitted Edge. */
+export type BoundEdge<Class extends ResolvedClass<'edge'> = ResolvedClass<'edge'>> = Edge & PropertyShortcutsOf<Class, EdgeReserved> & PropertyAccessOf<Class>;
+export type BoundGraphValue<Class extends AnyResolvedClass> = Class extends ResolvedClass<'node'> ? BoundNode<Class> : Class extends ResolvedClass<'edge'> ? BoundEdge<Class> : never;
+export {};

package/dist/graph/domain/model.js

@@ -0,0 +1 @@
+export {};

package/dist/graph/domain/page.d.ts

@@ -0,0 +1,23 @@
+import type { Edge } from '@astrale-os/kernel-core/graph/edge';
+import type { Node } from '@astrale-os/kernel-core/graph/node';
+import type { QueryAST, QueryEdgeGraphResult, QueryEdgeResult, QueryNodeGraphResult, QueryNodeResult, QueryResultFor, QuerySingleSourceClassOf } from '@astrale-os/kernel-core/graph/query';
+import type { AnyResolvedClass, ResolvedClass } from '@astrale-os/kernel-dsl/v1/language';
+import type { QueryResponse } from '../page-contract.js';
+import type { BoundEdge, BoundNode } from './model.js';
+type SourceClass<Query> = Extract<QuerySingleSourceClassOf<Query>, AnyResolvedClass>;
+export interface BoundNodePage<Query extends QueryAST = QueryAST, Class extends ResolvedClass<'node'> = Extract<SourceClass<Query>, ResolvedClass<'node'>>> {
+    readonly nodes: readonly BoundNode<Class>[];
+    readonly raw: QueryResponse<QueryResultFor<Query>>;
+    readonly next?: () => Promise<BoundNodePage<Query, Class>>;
+    refine<Target extends ResolvedClass<'node'>>(value: BoundNode<Class>, target: Target): BoundNode<Target> | undefined;
+}
+export interface BoundEdgePage<Query extends QueryAST = QueryAST, Class extends ResolvedClass<'edge'> = Extract<SourceClass<Query>, ResolvedClass<'edge'>>> {
+    readonly edges: readonly BoundEdge<Class>[];
+    readonly raw: QueryResponse<QueryResultFor<Query>>;
+    readonly next?: () => Promise<BoundEdgePage<Query, Class>>;
+    refine<Target extends ResolvedClass<'edge'>>(value: BoundEdge<Class>, target: Target): BoundEdge<Target> | undefined;
+}
+export type BoundQueryPage<Query extends QueryAST> = QueryResultFor<Query> extends QueryNodeGraphResult | QueryNodeResult ? BoundNodePage<Query> : QueryResultFor<Query> extends QueryEdgeGraphResult | QueryEdgeResult ? BoundEdgePage<Query> : never;
+export declare function selectedNodes(response: QueryResponse): readonly Node[];
+export declare function selectedEdges(response: QueryResponse): readonly Edge[];
+export {};

package/dist/graph/domain/page.js

@@ -0,0 +1,42 @@
+import { edgeKeyOf, equalEdgeKeys } from '@astrale-os/kernel-core/graph/edge';
+export function selectedNodes(response) {
+    const result = response.result;
+    if (result.kind === 'graph') {
+        if (result.selection.kind !== 'node')
+            throw new TypeError('Query did not select Nodes.');
+        const byId = new Map(result.graph.nodes.map((node) => [node.id, node]));
+        return result.selection.ids.map((id) => {
+            const node = byId.get(id);
+            if (node === undefined)
+                throw new TypeError(`Selected Node ${id} is absent.`);
+            return node;
+        });
+    }
+    if (result.kind !== 'nodes')
+        throw new TypeError('Query did not select Nodes.');
+    return result.nodes.map((item) => {
+        if (item.kind !== 'value')
+            throw new TypeError('Rich Node queries require value projection.');
+        return item.value;
+    });
+}
+export function selectedEdges(response) {
+    const result = response.result;
+    if (result.kind === 'graph') {
+        if (result.selection.kind !== 'edge')
+            throw new TypeError('Query did not select Edges.');
+        return result.selection.keys.map((key) => {
+            const edge = result.graph.edges.find((candidate) => equalEdgeKeys(edgeKeyOf(candidate), key));
+            if (edge === undefined)
+                throw new TypeError('Selected Edge is absent.');
+            return edge;
+        });
+    }
+    if (result.kind !== 'edges')
+        throw new TypeError('Query did not select Edges.');
+    return result.edges.map((item) => {
+        if (item.edge.kind !== 'value')
+            throw new TypeError('Rich Edge queries require value projection.');
+        return item.edge.value;
+    });
+}

package/dist/graph/domain/project.d.ts

@@ -0,0 +1,8 @@
+import type { Edge } from '@astrale-os/kernel-core/graph/edge';
+import type { Node } from '@astrale-os/kernel-core/graph/node';
+import type { ResolvedClass, ResolvedMethod } from '@astrale-os/kernel-dsl/v1/language';
+import type { BoundEdge, BoundNode } from './model.js';
+import type { QueryProvenance } from './provenance.js';
+export type MethodCall = (node: Node, method: ResolvedMethod, input: unknown) => Promise<unknown>;
+export declare function projectNode<Class extends ResolvedClass<'node'>>(selected: Class, node: Node, provenance: QueryProvenance, call: MethodCall): BoundNode<Class>;
+export declare function projectEdge<Class extends ResolvedClass<'edge'>>(selected: Class, edge: Edge, provenance: QueryProvenance): BoundEdge<Class>;

package/dist/graph/domain/project.js

@@ -0,0 +1,120 @@
+import { MethodKey, PropertyKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import { retainProjectedProvenance } from './provenance.js';
+export function projectNode(selected, node, provenance, call) {
+    const property = propertyAccessor(selected, node.props);
+    const method = methodAccessor(selected, node, call);
+    const value = {
+        id: node.id,
+        class: node.class,
+        props: node.props,
+        property,
+        method,
+    };
+    installPropertyShortcuts(value, selected, node.props, NODE_RESERVED);
+    installMethodShortcuts(value, selected, node, call, NODE_RESERVED);
+    const projected = Object.freeze(value);
+    retainProjectedProvenance(projected, provenance);
+    return projected;
+}
+export function projectEdge(selected, edge, provenance) {
+    const value = {
+        source: edge.source,
+        target: edge.target,
+        class: edge.class,
+        ...(edge.slug === undefined ? {} : { slug: edge.slug }),
+        props: edge.props,
+        property: propertyAccessor(selected, edge.props),
+    };
+    installPropertyShortcuts(value, selected, edge.props, EDGE_RESERVED);
+    const projected = Object.freeze(value);
+    retainProjectedProvenance(projected, provenance);
+    return projected;
+}
+const NODE_RESERVED = new Set(['id', 'class', 'props', 'property', 'method']);
+const EDGE_RESERVED = new Set(['source', 'target', 'class', 'slug', 'props', 'property']);
+function propertyAccessor(selected, props) {
+    return (input) => {
+        const property = resolveProperty(selected, input);
+        return props[property.key];
+    };
+}
+function methodAccessor(selected, node, call) {
+    return (input) => {
+        const method = resolveMethod(selected, input);
+        if (method.inheritance === 'abstract') {
+            throw new TypeError(`Abstract Method ${method.key} cannot be invoked.`);
+        }
+        return (value) => call(node, method, value);
+    };
+}
+function resolveProperty(selected, input) {
+    if (typeof input !== 'string') {
+        const member = selected.properties.get(input.key);
+        if (member !== input)
+            throw new TypeError('Property does not belong to the selected Class.');
+        return member;
+    }
+    if (PropertyKey.is(input)) {
+        const member = selected.properties.get(input);
+        if (member === undefined)
+            throw new TypeError(`Property ${input} is not effective.`);
+        return member;
+    }
+    const member = named(selected.properties, input);
+    if (member === undefined || typeof member !== 'object') {
+        throw new TypeError(`Property name ${JSON.stringify(input)} is absent or ambiguous.`);
+    }
+    return member;
+}
+function resolveMethod(selected, input) {
+    if (typeof input !== 'string') {
+        const member = selected.methods.get(input.key);
+        if (member !== input)
+            throw new TypeError('Method does not belong to the selected Class.');
+        return member;
+    }
+    if (MethodKey.is(input)) {
+        const member = selected.methods.get(input);
+        if (member === undefined)
+            throw new TypeError(`Method ${input} is not effective.`);
+        return member;
+    }
+    const member = named(selected.methods, input);
+    if (member === undefined || typeof member !== 'object') {
+        throw new TypeError(`Method name ${JSON.stringify(input)} is absent or ambiguous.`);
+    }
+    return member;
+}
+function installPropertyShortcuts(target, selected, props, reserved) {
+    for (const property of selected.properties) {
+        if (reserved.has(property.name) || hasOwn(target, property.name))
+            continue;
+        if (named(selected.properties, property.name) !== property)
+            continue;
+        if (selected.kind === 'node' && named(selected.methods, property.name) !== undefined)
+            continue;
+        install(target, property.name, props[property.key]);
+    }
+}
+function installMethodShortcuts(target, selected, node, call, reserved) {
+    for (const member of selected.methods) {
+        if (member.inheritance === 'abstract' ||
+            reserved.has(member.name) ||
+            hasOwn(target, member.name))
+            continue;
+        if (named(selected.methods, member.name) !== member)
+            continue;
+        if (named(selected.properties, member.name) !== undefined)
+            continue;
+        install(target, member.name, (input) => call(node, member, input));
+    }
+}
+function named(collection, name) {
+    return hasOwn(collection, name) ? Reflect.get(collection, name) : undefined;
+}
+function hasOwn(value, name) {
+    return Object.prototype.hasOwnProperty.call(value, name);
+}
+function install(target, name, value) {
+    Object.defineProperty(target, name, { enumerable: true, value });
+}

package/dist/graph/domain/provenance.d.ts

@@ -0,0 +1,6 @@
+import type { Domain } from '@astrale-os/kernel-dsl/v1/domain';
+import type { QueryProvenance } from '../provenance.js';
+export declare function retainProjectedProvenance(value: object, provenance: QueryProvenance): void;
+export declare function provenanceOfProjectedValue(value: object): QueryProvenance | undefined;
+export declare function sameClosure(left: Domain['closure'], right: Domain['closure']): boolean;
+export type { QueryProvenance };

package/dist/graph/domain/provenance.js

@@ -0,0 +1,11 @@
+const projectedValues = new WeakMap();
+export function retainProjectedProvenance(value, provenance) {
+    projectedValues.set(value, provenance);
+}
+export function provenanceOfProjectedValue(value) {
+    return projectedValues.get(value);
+}
+export function sameClosure(left, right) {
+    return (left.length === right.length &&
+        left.every((identity, index) => identity.origin === right[index]?.origin && identity.revision === right[index]?.revision));
+}

package/dist/graph/errors.d.ts

@@ -1,9 +1,8 @@
-import type { NodePath, PathLike } from '@astrale-os/kernel-core/path';
+import type { NodePath, NodeTarget } from '@astrale-os/kernel-core/path';
 import { ClientError } from '../errors/index.js';
 /** Required point read whose absence and authorization masking are intentionally indistinguishable. */
 export declare class NodeUnavailableError extends ClientError {
     readonly code: 'NODE_UNAVAILABLE';
     readonly path: NodePath;
-    constructor(path: PathLike);
+    constructor(path: NodeTarget);
 }
-//# sourceMappingURL=errors.d.ts.map

package/dist/graph/errors.js

@@ -5,10 +5,9 @@ export class NodeUnavailableError extends ClientError {
     code = 'NODE_UNAVAILABLE';
     path;
     constructor(path) {
-        const admitted = Path.from(path).raw;
+        const admitted = Path.target(path).raw;
         super(`Node ${JSON.stringify(admitted)} is unavailable.`);
         this.name = 'NodeUnavailableError';
         this.path = admitted;
     }
 }
-//# sourceMappingURL=errors.js.map

package/dist/graph/expectation.d.ts

@@ -0,0 +1,3 @@
+import type { DomainDependency } from '@astrale-os/kernel-dsl/v1/schema';
+/** Detach one caller-owned expected closure before crossing the Client boundary. */
+export declare function captureExpected(input: readonly DomainDependency[] | undefined): readonly DomainDependency[] | undefined;

package/dist/graph/expectation.js

@@ -0,0 +1,6 @@
+/** Detach one caller-owned expected closure before crossing the Client boundary. */
+export function captureExpected(input) {
+    if (input === undefined)
+        return undefined;
+    return Object.freeze(input.map(({ origin, revision }) => Object.freeze({ origin, revision })));
+}

package/dist/graph/graph.d.ts

@@ -1,25 +1,29 @@
 import type { GraphSpec } from '@astrale-os/kernel-core/graph/graph';
 import type { MutationAST as MutationASTValue, MutationBuilder, MutationInput, MutationResult as MutationResultValue } from '@astrale-os/kernel-core/graph/mutate';
 import type { Node } from '@astrale-os/kernel-core/graph/node';
-import type { QueryAST as QueryASTValue, QueryDefinitionRef, QueryResultFor } from '@astrale-os/kernel-core/graph/query';
-import type { PathLike } from '@astrale-os/kernel-core/path';
+import type { QueryAST as QueryASTValue, QueryEdgeClassInput, QueryResultFor } from '@astrale-os/kernel-core/graph/query';
+import type { NodeTarget } from '@astrale-os/kernel-core/path';
+import type { DomainDependency } from '@astrale-os/kernel-dsl/v1/schema';
 import type { Call, Input } from '../client/index.js';
 import type { RequestOptions } from '../transport/index.js';
 import type { QueryPageRequest, QueryResponse } from './page-contract.js';
 import type { NeighborsOptions, NodePage } from './page/index.js';
 export type GraphCall = (call: Call, options?: RequestOptions) => Promise<Input>;
 export interface GraphQueryOptions extends RequestOptions {
+    readonly expected?: readonly DomainDependency[];
     readonly page: QueryPageRequest;
 }
+export interface GraphMutationOptions extends RequestOptions {
+    readonly expected?: readonly DomainDependency[];
+}
 export type MutationAuthor = (mutation: MutationBuilder) => undefined;
 export interface GraphApi {
     query<Query extends QueryASTValue>(ast: Query, options: GraphQueryOptions): Promise<QueryResponse<QueryResultFor<Query>>>;
-    mutate(author: MutationAuthor, options?: RequestOptions): Promise<MutationResultValue>;
-    mutate(ast: MutationASTValue | MutationInput | GraphSpec, options?: RequestOptions): Promise<MutationResultValue>;
-    get(target: PathLike, options?: RequestOptions): Promise<Node | null>;
-    getOrThrow(target: PathLike, options?: RequestOptions): Promise<Node>;
-    neighbors(source: PathLike, via: QueryDefinitionRef | readonly [QueryDefinitionRef, ...QueryDefinitionRef[]], options: NeighborsOptions): Promise<NodePage>;
+    mutate(author: MutationAuthor, options?: GraphMutationOptions): Promise<MutationResultValue>;
+    mutate(ast: MutationASTValue | MutationInput | GraphSpec, options?: GraphMutationOptions): Promise<MutationResultValue>;
+    get(target: NodeTarget, options?: RequestOptions): Promise<Node | null>;
+    getOrThrow(target: NodeTarget, options?: RequestOptions): Promise<Node>;
+    neighbors(source: NodeTarget, via: QueryEdgeClassInput | readonly [QueryEdgeClassInput, ...QueryEdgeClassInput[]], options: NeighborsOptions): Promise<NodePage>;
 }
 /** Bind Core's canonical graph documents to one caller-scoped value-call capability. */
 export declare function createGraph(call: GraphCall): GraphApi;
-//# sourceMappingURL=graph.d.ts.map

package/dist/graph/graph.js

@@ -16,4 +16,3 @@ export function createGraph(call) {
         neighbors: (source, via, options) => readNeighbors(query, source, via, options),
     });
 }
-//# sourceMappingURL=graph.js.map

package/dist/graph/index.d.ts

@@ -1,8 +1,8 @@
-export { createGraph, type GraphApi, type GraphCall, type GraphQueryOptions, type MutationAuthor, } from './graph.js';
+export { createGraph, type GraphApi, type GraphCall, type GraphMutationOptions, type GraphQueryOptions, type MutationAuthor, } from './graph.js';
 export type { QueryPageRequest, QueryResponse } from './page-contract.js';
+export { type BoundEdge, type BoundEdgePage, type BoundGraphValue, type BoundNode, type BoundNodeFor, type BoundNodePage, type BoundQueryPage, type DomainBinding, type DomainQueryOptions, } from './domain/index.js';
 export { NodeUnavailableError } from './errors.js';
 export type { NeighborsOptions, NodePage } from './page/index.js';
 export { LocalBinding, type GraphSpec } from '@astrale-os/kernel-core/graph/graph';
 export { MutationAST, MutationResult, type MutationBuilder, type MutationInput, } from '@astrale-os/kernel-core/graph/mutate';
 export { Query, QueryAST, QueryResult } from '@astrale-os/kernel-core/graph/query';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/index.js

@@ -1,6 +1,6 @@
 export { createGraph, } from './graph.js';
+export {} from './domain/index.js';
 export { NodeUnavailableError } from './errors.js';
 export { LocalBinding } from '@astrale-os/kernel-core/graph/graph';
 export { MutationAST, MutationResult, } from '@astrale-os/kernel-core/graph/mutate';
 export { Query, QueryAST, QueryResult } from '@astrale-os/kernel-core/graph/query';
-//# sourceMappingURL=index.js.map

package/dist/graph/mutation.d.ts

@@ -1,6 +1,4 @@
 import type { GraphSpec } from '@astrale-os/kernel-core/graph/graph';
 import type { MutationAST as MutationASTValue, MutationInput, MutationResult as MutationResultValue } from '@astrale-os/kernel-core/graph/mutate';
-import type { RequestOptions } from '../transport/index.js';
-import type { GraphCall, MutationAuthor } from './graph.js';
-export declare function mutateGraph(call: GraphCall, input: MutationAuthor | MutationASTValue | MutationInput | GraphSpec, options?: RequestOptions): Promise<MutationResultValue>;
-//# sourceMappingURL=mutation.d.ts.map
+import type { GraphCall, GraphMutationOptions, MutationAuthor } from './graph.js';
+export declare function mutateGraph(call: GraphCall, input: MutationAuthor | MutationASTValue | MutationInput | GraphSpec, options?: GraphMutationOptions): Promise<MutationResultValue>;

package/dist/graph/mutation.js

@@ -2,10 +2,19 @@ import { MutationAST, MutationResult } from '@astrale-os/kernel-core/graph/mutat
 import { Path } from '@astrale-os/kernel-core/path';
 import { mutate } from '@astrale-os/kernel-core/schema/kernel/syscalls/references';
 import { call as invocation } from '../client/index.js';
+import { captureExpected } from './expectation.js';
 const KERNEL_MUTATE_PATH = Path.project(mutate).raw;
 export async function mutateGraph(call, input, options) {
     const ast = typeof input === 'function' ? MutationAST.build(input) : admitMutation(input);
-    const output = await call(invocation(KERNEL_MUTATE_PATH, ast), options);
+    const expected = options?.expected;
+    const request = options === undefined
+        ? undefined
+        : (({ expected: _expected, ...rest }) => rest)(options);
+    const capturedExpected = captureExpected(expected);
+    const output = await call(invocation(KERNEL_MUTATE_PATH, Object.freeze({
+        ast,
+        ...(capturedExpected === undefined ? {} : { expected: capturedExpected }),
+    })), request);
     return MutationResult.decode(output);
 }
 function admitMutation(input) {
@@ -15,4 +24,3 @@ function admitMutation(input) {
             ? MutationAST.create(input)
             : MutationAST.fromGraph(input);
 }
-//# sourceMappingURL=mutation.js.map

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

@@ -1,3 +1,2 @@
 export { type NeighborsOptions, type NeighborSource, type NeighborVia, readNeighbors, } from './neighbors.js';
 export type { NodePage, PageQuery, PageQueryOptions } from './page.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/page/index.js

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

package/dist/graph/page/neighbors.d.ts

@@ -1,10 +1,9 @@
-import type { QueryDefinitionRef, QueryDirection } from '@astrale-os/kernel-core/graph/query';
-import type { PathLike } from '@astrale-os/kernel-core/path';
+import type { QueryDirection, QueryEdgeClassInput } from '@astrale-os/kernel-core/graph/query';
+import type { NodeTarget } from '@astrale-os/kernel-core/path';
 import type { NodePage, PageQuery, PageQueryOptions } from './page.js';
 export interface NeighborsOptions extends PageQueryOptions {
     readonly direction: QueryDirection;
 }
-export type NeighborSource = PathLike;
-export type NeighborVia = QueryDefinitionRef | readonly [QueryDefinitionRef, ...QueryDefinitionRef[]];
+export type NeighborSource = NodeTarget;
+export type NeighborVia = QueryEdgeClassInput | readonly [QueryEdgeClassInput, ...QueryEdgeClassInput[]];
 export declare function readNeighbors(query: PageQuery, source: NeighborSource, via: NeighborVia, options: NeighborsOptions): Promise<NodePage>;
-//# sourceMappingURL=neighbors.d.ts.map

package/dist/graph/page/neighbors.js

@@ -1,13 +1,14 @@
 import { Query } from '@astrale-os/kernel-core/graph/query';
+import { queryNodePath } from '../query.js';
 import { createNodePage } from './page.js';
 export async function readNeighbors(query, source, via, options) {
     if (options === null || typeof options !== 'object') {
         throw new TypeError('Neighbor read options are invalid.');
     }
-    const definitions = Array.isArray(via) ? via : [via];
-    const [definition, ...additionalDefinitions] = definitions;
-    if (definition === undefined)
-        throw new TypeError('Neighbor read requires at least one Definition.');
+    const classes = Array.isArray(via) ? via : [via];
+    const [classInput, ...additionalClasses] = classes;
+    if (classInput === undefined)
+        throw new TypeError('Neighbor read requires at least one Class.');
     const direction = options.direction === 'outgoing'
         ? options.direction
         : options.direction === 'incoming'
@@ -15,8 +16,8 @@ export async function readNeighbors(query, source, via, options) {
             : options.direction === 'incident'
                 ? options.direction
                 : invalidDirection(options.direction);
-    const ast = Query.from({ kind: 'node', paths: [source] })
-        .expand({ via: [definition, ...additionalDefinitions], direction })
+    const ast = Query.from({ nodes: [queryNodePath(source)] })
+        .expand({ via: [classInput, ...additionalClasses], direction })
         .select({ kind: 'graph' });
     const { direction: _, page, ...request } = options;
     const { idempotencyKey: ___, ...basis } = request;
@@ -32,4 +33,3 @@ export async function readNeighbors(query, source, via, options) {
 function invalidDirection(input) {
     throw new TypeError(`Unsupported neighbor direction ${JSON.stringify(input)}.`);
 }
-//# sourceMappingURL=neighbors.js.map

package/dist/graph/page/page.d.ts

@@ -1,6 +1,7 @@
 import type { GraphData } from '@astrale-os/kernel-core/graph/graph';
 import type { Node, NodeCollection } from '@astrale-os/kernel-core/graph/node';
 import type { NodeBinding, QueryAST, QueryGraphSelect, QueryNodeGraphResult, QueryResultFor } from '@astrale-os/kernel-core/graph/query';
+import type { DomainDependency } from '@astrale-os/kernel-dsl/v1/schema';
 import type { RequestOptions } from '../../transport/index.js';
 import type { QueryPageRequest, QueryResponse } from '../page-contract.js';
 export interface NodePage {
@@ -23,12 +24,14 @@ export interface NodePage {
         readonly cursor: string | null;
     }>;
 }
-type PageBasis = Pick<RequestOptions, 'signal' | 'timeoutMs'>;
+type PageBasis = Pick<RequestOptions, 'signal' | 'timeoutMs'> & {
+    readonly expected?: readonly DomainDependency[];
+};
 export interface PageQueryOptions extends RequestOptions {
+    readonly expected?: readonly DomainDependency[];
     readonly page: QueryPageRequest;
 }
 export type PageQuery = <Query extends QueryAST>(ast: Query, options: PageQueryOptions) => Promise<QueryResponse<QueryResultFor<Query>>>;
 type NodeGraphQueryAST = QueryAST<QueryGraphSelect<NodeBinding>>;
 export declare function createNodePage(query: PageQuery, ast: NodeGraphQueryAST, response: QueryResponse<QueryNodeGraphResult>, basis: PageBasis, size: number): NodePage;
 export {};
-//# sourceMappingURL=page.d.ts.map

package/dist/graph/page/page.js

@@ -53,4 +53,3 @@ function requireMaximumPages(value) {
         throw new TypeError('NodePage maximumPages must be a positive safe integer.');
     }
 }
-//# sourceMappingURL=page.js.map