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

package/dist/session/session.d.ts

@@ -1,16 +1,17 @@
 import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
 import type { PathLike } from '@astrale-os/kernel-core/path';
-import type { Key } from '@astrale-os/kernel-dsl/v1';
+import type { Domain } from '@astrale-os/kernel-dsl/v1/domain';
 import type { Call, Input, Result } from '../client/index.js';
+import type { DomainBinding, GraphApi } from '../graph/index.js';
 import type { ClientFactory, ClientPool as ClientPoolType } from '../pool/index.js';
-import type { ReadyInstallation, SchemaApi } from '../schema/index.js';
+import type { SchemaApi } from '../schema/index.js';
 import type { ClientWarning } from '../transport/auto/index.js';
 import type { Fetch } from '../transport/http/index.js';
 import type { WebSocketConstructor } from '../transport/websocket/index.js';
 import type { SessionControlOptions, SessionPolicy } from './context/index.js';
 import type { SessionSnapshot } from './discovery/index.js';
 import type { CallableReference, InputOfReference, OutputOfReference } from './reference.js';
-import type { SessionAuth, SessionEnvelopeTransport, SessionRequestOptions } from './routing/index.js';
+import type { SessionRouteStore, SessionAuth, SessionEnvelopeTransport, SessionRequestOptions } from './routing/index.js';
 import type { ViewCatalog } from './views/index.js';
 export interface ClientSessionOptions {
     /** Exact canonical source Kernel identity; its invocation and discovery endpoints are derived. */
@@ -20,6 +21,8 @@ export interface ClientSessionOptions {
     readonly pool?: Pick<ClientPoolType, 'clientFor'>;
     readonly websocket?: WebSocketConstructor;
     readonly auth?: SessionAuth;
+    /** Optional caller-owned persistence for bounded confidential route artifacts. */
+    readonly routeStore?: SessionRouteStore;
     readonly policy: SessionPolicy;
     readonly envelopeTransport?: SessionEnvelopeTransport;
     readonly onWarning?: (warning: ClientWarning) => void;
@@ -27,6 +30,7 @@ export interface ClientSessionOptions {
     readonly maximumBundleBytes?: number;
     readonly maximumResponseBytes?: number;
     readonly timeoutMs?: number;
+    readonly schemaLifecycleTimeoutMs?: number;
 }
 export type ConnectOptions = Omit<ClientSessionOptions, 'kernel' | 'policy'> & {
     readonly url: string;
@@ -36,6 +40,7 @@ export type ConnectOptions = Omit<ClientSessionOptions, 'kernel' | 'policy'> & {
 export declare class ClientSession {
     readonly kernel: IssuerId;
     readonly schema: SchemaApi;
+    readonly graph: GraphApi;
     private readonly ownedPool?;
     private readonly discovery;
     private readonly dispatcher;
@@ -45,18 +50,19 @@ export declare class ClientSession {
     private readonly admitTargetViews;
     private closed;
     constructor(options: ClientSessionOptions);
+    /** Bind one admitted DSL Domain to authenticated graph projection and Method dispatch. */
+    bind<const DomainValue extends Domain>(domain: DomainValue): DomainBinding<DomainValue>;
     snapshot(options?: SessionControlOptions): Promise<SessionSnapshot>;
     viewsFor(target: PathLike, options?: SessionControlOptions): Promise<ViewCatalog>;
-    installation(origin: Key.Origin, options?: SessionControlOptions): Promise<ReadyInstallation>;
     dispatch(call: Call, options?: SessionRequestOptions): Promise<Result>;
     call(call: Call, options?: SessionRequestOptions): Promise<Input>;
     invoke<const Reference extends CallableReference>(reference: Reference, input: InputOfReference<Reference>, options?: SessionRequestOptions): Promise<OutputOfReference<Reference>>;
     stream(call: Call, options?: SessionRequestOptions): Promise<import("../client/result.js").Stream>;
-    binary(call: Call, options?: SessionRequestOptions): Promise<import("@astrale-os/kernel-core/domain").BinaryResult>;
+    binary(call: Call, options?: SessionRequestOptions): Promise<import("@astrale-os/kernel-core/callable").BinaryOutput>;
     close(): void;
     private requireOpen;
+    private invokeDomainMethod;
     private operation;
 }
 /** Open one caller-owned conversation with a Kernel using secure defaults. */
 export declare function connect(options: ConnectOptions): ClientSession;
-//# sourceMappingURL=session.d.ts.map

package/dist/session/session.js

@@ -1,7 +1,10 @@
+import { Path } from '@astrale-os/kernel-core/path';
 import { Client } from '../client/index.js';
-import { ClientError } from '../errors/index.js';
+import { SessionError } from '../errors/index.js';
+import { createDomainBinding } from '../graph/domain/binding.js';
+import { createGraph } from '../graph/index.js';
 import { ClientPool } from '../pool/index.js';
-import { createSchema } from '../schema/index.js';
+import { createSchema, DEFAULT_SCHEMA_LIFECYCLE_TIMEOUT_MS } from '../schema/index.js';
 import { AutoTransport } from '../transport/auto/index.js';
 import { HttpTransport } from '../transport/http/index.js';
 import { WebSocketTransport } from '../transport/websocket/index.js';
@@ -15,6 +18,7 @@ const DEFAULT_SESSION_POLICY = Object.freeze({ maximumRouteAgeMs: 60_000 });
 export class ClientSession {
     kernel;
     schema;
+    graph;
     ownedPool;
     discovery;
     dispatcher;
@@ -42,11 +46,12 @@ export class ClientSession {
         const maximumBundleBytes = positive(options.maximumBundleBytes ?? DEFAULT_MAXIMUM_BUNDLE_BYTES, 'maximumBundleBytes');
         const maximumResponseBytes = positive(options.maximumResponseBytes ?? DEFAULT_MAXIMUM_RESPONSE_BYTES, 'maximumResponseBytes');
         const timeoutMs = platformDuration(options.timeoutMs ?? DEFAULT_TIMEOUT_MS, 'timeoutMs');
+        const schemaLifecycleTimeoutMs = platformDuration(options.schemaLifecycleTimeoutMs ?? DEFAULT_SCHEMA_LIFECYCLE_TIMEOUT_MS, 'schemaLifecycleTimeoutMs');
         this.timeoutMs = timeoutMs;
         const websocketAvailable = options.client !== undefined ||
             options.pool !== undefined ||
             options.websocket !== undefined ||
-            typeof globalThis.WebSocket === 'function';
+            typeof WebSocket === 'function';
         const client = options.client ??
             defaultClientFactory({
                 fetch: fetchImpl,
@@ -73,7 +78,7 @@ export class ClientSession {
             requireOpen: () => this.requireOpen(),
             acquisitionOperation: () => this.operation(undefined),
         });
-        this.routes = new RouteCache(policy.maximumRouteAgeMs);
+        this.routes = new RouteCache(policy.maximumRouteAgeMs, undefined, options.routeStore);
         this.dispatcher = new SessionDispatcher({
             kernel: this.kernel,
             sourceEndpoint,
@@ -83,13 +88,18 @@ export class ClientSession {
             cache: this.routes,
             policy,
             envelopeTransport: admitEnvelopeTransport(options.envelopeTransport ?? 'http'),
-            discovery: this.discovery,
             requireOpen: () => this.requireOpen(),
         });
         this.schema = createSchema((request, options) => this.dispatch(request, options), {
             maximumPublicationBytes,
             maximumBundleBytes,
+            lifecycleTimeoutMs: schemaLifecycleTimeoutMs,
         });
+        this.graph = createGraph((call, options) => this.call(call, options));
+    }
+    /** Bind one admitted DSL Domain to authenticated graph projection and Method dispatch. */
+    bind(domain) {
+        return createDomainBinding(domain, this.graph, (node, method, input) => this.invokeDomainMethod(domain, node, method, input));
     }
     snapshot(options) {
         return this.discovery.snapshot(this.operation(admitControlOptions(options)));
@@ -98,23 +108,6 @@ export class ClientSession {
         this.requireOpen();
         return resolveViewsFor(async (call, operation) => requireResultKind('value', await this.dispatcher.dispatch(call, {}, operation)).value, this.admitTargetViews, target, this.operation(admitControlOptions(options)));
     }
-    async installation(origin, options) {
-        const result = await this.schema.introspect({
-            from: { kind: 'installation', origin },
-            select: {
-                state: true,
-                target: true,
-                source: true,
-                bundle: true,
-                readiness: true,
-                capabilities: true,
-            },
-        }, options);
-        if (result?.state !== 'ready' || result.readiness === null) {
-            throw new ClientError(`Domain ${origin} is not ready on this Kernel.`);
-        }
-        return result;
-    }
     dispatch(call, options) {
         const admitted = admitRequestOptions(options);
         return this.dispatcher.dispatch(call, admitted, this.operation(admitted));
@@ -150,14 +143,29 @@ export class ClientSession {
         if (this.closed)
             return;
         this.closed = true;
-        this.lifecycle.abort(new ClientError('ClientSession is closed.'));
+        this.lifecycle.abort(new SessionError('ClientSession is closed.', { failure: 'closed' }));
         this.ownedPool?.close();
         this.routes.clear();
         this.discovery.clear();
     }
     requireOpen() {
         if (this.closed)
-            throw new ClientError('ClientSession is closed.');
+            throw new SessionError('ClientSession is closed.', { failure: 'closed' });
+    }
+    invokeDomainMethod(domain, node, method, input) {
+        const diagnostics = method.validateInput(input);
+        if (diagnostics.length > 0)
+            throw new TypeError(`Method ${method.key} input is invalid.`);
+        const owner = domain.closure.find(({ origin }) => origin === method.owner.ref.origin);
+        if (owner === undefined)
+            throw new TypeError(`Method owner ${method.owner.ref.origin} is absent.`);
+        return this.invoke({
+            origin: owner.origin,
+            revision: owner.revision,
+            callable: method.key,
+            target: Path.instanceMethod(Path.id(node.id), method.name),
+            outputMode: method.output.mode,
+        }, input);
     }
     operation(options) {
         this.requireOpen();
@@ -231,4 +239,3 @@ function defaultClientFactory(options) {
         }
     };
 }
-//# sourceMappingURL=session.js.map

package/dist/session/session.typecheck.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=session.typecheck.d.ts.map

package/dist/session/session.typecheck.js

@@ -1,4 +1,7 @@
-import { ClientSession } from './index.js';
+import { NodeId } from '@astrale-os/kernel-core/graph/node';
+import { Path } from '@astrale-os/kernel-core/path';
+import { defineSchema, method, nodeClass, schema } from '@astrale-os/kernel-dsl/v1';
+import { ClientSession, reference } from './index.js';
 void new ClientSession(options);
 void auth;
 void control;
@@ -6,5 +9,22 @@ void envelope;
 void policy;
 void request;
 void snapshot;
-void {};
-//# sourceMappingURL=session.typecheck.js.map
+const dynamicReference = reference(dynamicDomain, dynamicMethod)(Path.id(NodeId('dynamic-node')));
+void session.invoke(dynamicReference, dynamicInput);
+const dynamicInputIsClientInput = true;
+const dynamicOutputIsUnknown = true;
+void dynamicInputIsClientInput;
+void dynamicOutputIsUnknown;
+const abstractMethod = method({
+    auth: 'authenticated',
+    input: { type: 'null' },
+    output: { type: 'null' },
+    inheritance: 'abstract',
+});
+const abstractDomain = schema.resolve(defineSchema('client.reference.typecheck', {
+    classes: {
+        AbstractItem: nodeClass({ abstract: true, methods: { abstractMethod } }),
+    },
+}));
+// @ts-expect-error Abstract Methods are declarations and cannot become Client references.
+reference(abstractDomain, abstractDomain.classes.AbstractItem.methods.abstractMethod);

package/dist/session/views/catalog.d.ts

@@ -13,4 +13,3 @@ export declare function rootViewCatalog(publication: publication.Publication, ar
 export declare function catalogFromKeys(root: ViewCatalog, keys: readonly Key.View[]): ViewCatalog;
 /** Re-admit one Runtime-resolved heterogeneous View catalog at the Client trust boundary. */
 export declare function targetViewCatalog(input: unknown, policy: Readonly<SessionPolicy>): ViewCatalog;
-//# sourceMappingURL=catalog.d.ts.map

package/dist/session/views/catalog.js

@@ -1,20 +1,22 @@
 import { acceptViewResolution, } from '@astrale-os/kernel-core/schema/kernel/syscalls/view-resolution';
-import { Key as ViewKey, Ref } from '@astrale-os/kernel-dsl/v1/addressing';
+import { Key as ViewKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { ClientError } from '../../errors/index.js';
 import { allowEndpoint } from '../context/index.js';
 export function rootViewCatalog(publication, artifact, policy) {
     const views = publication.bindings.views
         .map((binding) => {
         allowEndpoint(binding.href, policy);
-        const declaration = artifact.root.views[Ref.member(ViewKey.ref(binding.view))];
+        const declaration = artifact.root.views[viewName(binding.view)];
         if (declaration === undefined) {
             throw new ClientError('Published View has no verified root declaration.');
         }
+        const { ref: _ref, ...viewDeclaration } = declaration;
         return Object.freeze({
             key: binding.view,
-            declaration,
+            declaration: Object.freeze(viewDeclaration),
             href: binding.href,
             handshake: binding.handshake,
+            ...(binding.iframe === undefined ? {} : { iframe: binding.iframe }),
             issuer: publication.identity.issuer,
             etag: publication.etag,
             revision: publication.schema.revision,
@@ -25,7 +27,7 @@ export function rootViewCatalog(publication, artifact, policy) {
     const entrypointRef = publication.manifest?.entrypoint;
     const entrypoint = entrypointRef === undefined
         ? undefined
-        : catalogViews.find(({ key }) => key === ViewKey.of(publication.origin, entrypointRef));
+        : catalogViews.find(({ key }) => key === ViewKey.of(entrypointRef));
     if (entrypointRef !== undefined && entrypoint === undefined) {
         throw new ClientError('Published View entrypoint has no verified Publication binding.');
     }
@@ -60,4 +62,10 @@ export function targetViewCatalog(input, policy) {
 function compareKeys(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
-//# sourceMappingURL=catalog.js.map
+function viewName(input) {
+    const coordinate = input.slice(input.indexOf(':') + 1);
+    const match = /^view\.([A-Za-z][A-Za-z0-9_]*)$/u.exec(coordinate);
+    if (match === null)
+        throw new ClientError('Published View key is invalid.');
+    return match[1];
+}

package/dist/session/views/index.d.ts

@@ -1,3 +1,2 @@
 export { catalogFromKeys, rootViewCatalog, targetViewCatalog, type ResolvedView, type ViewCatalog, } from './catalog.js';
 export { resolveViewsFor, type ViewCatalogAdmission, type ViewInvoker } from './resolve.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/session/views/index.js

@@ -1,3 +1,2 @@
 export { catalogFromKeys, rootViewCatalog, targetViewCatalog, } from './catalog.js';
 export { resolveViewsFor } from './resolve.js';
-//# sourceMappingURL=index.js.map

package/dist/session/views/resolve.d.ts

@@ -9,4 +9,3 @@ export type ViewCatalogAdmission = (input: unknown) => ViewCatalog;
  * its heterogeneous installed-Publication projection.
  */
 export declare function resolveViewsFor(invoke: ViewInvoker, admitCatalog: ViewCatalogAdmission, target: PathLike, operation: SessionOperation): Promise<ViewCatalog>;
-//# sourceMappingURL=resolve.d.ts.map

package/dist/session/views/resolve.js

@@ -11,4 +11,3 @@ export async function resolveViewsFor(invoke, admitCatalog, target, operation) {
     const targetView = Path.staticMethod(owner, view.resolve.name);
     return admitCatalog(await invoke(call(targetView, { target: path }), operation));
 }
-//# sourceMappingURL=resolve.js.map

package/dist/store/entity-index.d.ts

@@ -20,4 +20,3 @@ export declare class EntityIndex {
     clear(): void;
 }
 export declare function edgeIdentity(key: EdgeKey): string;
-//# sourceMappingURL=entity-index.d.ts.map

package/dist/store/entity-index.js

@@ -92,4 +92,3 @@ export function edgeIdentity(key) {
 function signature(value) {
     return JSON.stringify(value);
 }
-//# sourceMappingURL=entity-index.js.map

package/dist/store/index.d.ts

@@ -1,2 +1 @@
 export { GraphStore, type StoreMutationOptions, type StoreOptions, type StoreQuery, type StoreQueryResponse, type StoreReadOptions, type StoreSnapshot, } from './store.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/store/index.js

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

package/dist/store/memory.d.ts

@@ -1,4 +1,5 @@
 import type { QueryAST } from '@astrale-os/kernel-core/graph/query';
+import type { DomainDependency } from '@astrale-os/kernel-dsl/v1/schema';
 import type { QueryPageRequest } from '../graph/index.js';
 import type { GraphApi } from '../graph/index.js';
 import type { StoreQueryResponse, StoreReadOptions, StoreSnapshot } from './store.js';
@@ -24,7 +25,7 @@ export declare class GraphMemory {
     private readonly pending;
     private active;
     constructor(options: GraphMemoryOptions);
-    ensure(key: string, ast: QueryAST, page: QueryPageRequest): QueryShape;
+    ensure(key: string, ast: QueryAST, page: QueryPageRequest, expected: readonly DomainDependency[] | undefined): QueryShape;
     get(key: string): QueryShape | undefined;
     read(shape: QueryShape, options: StoreReadOptions): Promise<StoreQueryResponse>;
     snapshot(shape: QueryShape | undefined): StoreSnapshot;
@@ -46,4 +47,3 @@ export declare class GraphMemory {
     private drain;
     private report;
 }
-//# sourceMappingURL=memory.d.ts.map

package/dist/store/memory.js

@@ -1,5 +1,6 @@
 import { encodeEdgeKey } from '@astrale-os/kernel-core/graph/edge';
 import { ClientError } from '../errors/index.js';
+import { retainDerivedQueryProvenance } from '../graph/provenance.js';
 import { edgeIdentity, EntityIndex } from './entity-index.js';
 import { OptimisticOverlay } from './optimistic.js';
 import { COLD_SNAPSHOT, QueryShape } from './shape.js';
@@ -13,7 +14,7 @@ export class GraphMemory {
     constructor(options) {
         this.options = options;
     }
-    ensure(key, ast, page) {
+    ensure(key, ast, page, expected) {
         const existing = this.shapes.get(key);
         const now = this.options.now();
         if (existing !== undefined) {
@@ -26,7 +27,7 @@ export class GraphMemory {
         if (this.shapes.size >= this.options.maximumShapes) {
             throw new ClientError('GraphStore shape capacity is exhausted by observed or in-flight queries.');
         }
-        const shape = new QueryShape(key, ast, page, now);
+        const shape = new QueryShape(key, ast, page, expected, now);
         shape.releasedAt = now;
         this.shapes.set(key, shape);
         return shape;
@@ -52,7 +53,7 @@ export class GraphMemory {
         const prior = shape.response;
         this.publish(shape, prior === undefined ? 'loading' : this.overlay.hasAny() ? 'optimistic' : 'refreshing');
         const inflight = this.schedule(async () => {
-            const result = await this.options.graph.query(shape.ast, queryOptions(shape.page, this.options.lifecycle));
+            const result = await this.options.graph.query(shape.ast, queryOptions(shape.page, this.options.lifecycle, shape.expected));
             this.options.requireOpen();
             const integration = this.entities.integrate(result.result);
             shape.references = integration.references;
@@ -182,10 +183,11 @@ export class GraphMemory {
             this.pending.shift()?.reject(error);
     }
     materialize(template, references) {
-        return Object.freeze({
+        const response = Object.freeze({
             result: this.materializeResult(template.result, references),
             page: template.page,
         });
+        return retainDerivedQueryProvenance(template, response);
     }
     materializeResult(template, references) {
         if (template.kind === 'nodes') {
@@ -196,8 +198,9 @@ export class GraphMemory {
                     continue;
                 }
                 const node = this.overlay.node(projection.value.id, this.entities);
-                if (node !== undefined)
-                    nodes.push(Object.freeze({ kind: 'value', value: node }));
+                if (node !== undefined) {
+                    nodes.push(Object.freeze({ kind: 'value', value: materializeNode(node) }));
+                }
             }
             return Object.freeze({
                 kind: 'nodes',
@@ -213,7 +216,7 @@ export class GraphMemory {
                         const value = this.entities.edge(edgeIdentity(item.edge.value));
                         return value === undefined
                             ? undefined
-                            : Object.freeze({ kind: 'value', value });
+                            : Object.freeze({ kind: 'value', value: materializeEdge(value) });
                     })();
                 const source = item.source.kind === 'reference'
                     ? item.source
@@ -221,7 +224,7 @@ export class GraphMemory {
                         const value = this.overlay.node(item.source.value.id, this.entities);
                         return value === undefined
                             ? undefined
-                            : Object.freeze({ kind: 'value', value });
+                            : Object.freeze({ kind: 'value', value: materializeNode(value) });
                     })();
                 const target = item.target.kind === 'reference'
                     ? item.target
@@ -229,7 +232,7 @@ export class GraphMemory {
                         const value = this.overlay.node(item.target.value.id, this.entities);
                         return value === undefined
                             ? undefined
-                            : Object.freeze({ kind: 'value', value });
+                            : Object.freeze({ kind: 'value', value: materializeNode(value) });
                     })();
                 if (edge !== undefined && source !== undefined && target !== undefined) {
                     edges.push(Object.freeze({ edge, source, target }));
@@ -242,11 +245,13 @@ export class GraphMemory {
         }
         const nodes = references.nodes
             .map((id) => this.overlay.node(id, this.entities))
-            .filter((node) => node !== undefined);
+            .filter((node) => node !== undefined)
+            .map(materializeNode);
         const visibleNodeIds = new Set(nodes.map(({ id }) => id));
         const edges = references.edges
             .map((key) => this.entities.edge(key))
-            .filter((edge) => edge !== undefined && visibleNodeIds.has(edge.source) && visibleNodeIds.has(edge.target));
+            .filter((edge) => edge !== undefined && visibleNodeIds.has(edge.source) && visibleNodeIds.has(edge.target))
+            .map(materializeEdge);
         const graph = Object.freeze({ nodes: Object.freeze(nodes), edges: Object.freeze(edges) });
         const selection = materializeSelection(template.selection, visibleNodeIds, edges);
         return selection.kind === 'node'
@@ -297,6 +302,12 @@ export class GraphMemory {
         }
     }
 }
+function materializeNode(value) {
+    return Object.freeze({ ...value });
+}
+function materializeEdge(value) {
+    return Object.freeze({ ...value });
+}
 function materializeSelection(selection, visibleNodes, visibleEdges) {
     if (selection.kind === 'node') {
         return Object.freeze({
@@ -310,10 +321,11 @@ function materializeSelection(selection, visibleNodes, visibleEdges) {
         keys: Object.freeze(selection.keys.filter((key) => edges.has(encodeEdgeKey(key)))),
     });
 }
-function queryOptions(page, lifecycle) {
+function queryOptions(page, lifecycle, expected) {
     return Object.freeze({
         signal: lifecycle,
         page,
+        ...(expected === undefined ? {} : { expected }),
     });
 }
 function observeRead(pending, options, lifecycle) {
@@ -394,4 +406,3 @@ function sameSnapshot(left, right) {
     }
     return left.state !== 'failed' || right.state !== 'failed' || left.error === right.error;
 }
-//# sourceMappingURL=memory.js.map

package/dist/store/mutation.d.ts

@@ -3,4 +3,3 @@ import type { GraphApi, MutationAuthor } from '../graph/index.js';
 import type { GraphMemory } from './memory.js';
 import type { StoreMutationOptions } from './store.js';
 export declare function mutateStore(graph: GraphApi, memory: GraphMemory, input: MutationAuthor | MutationASTValue | MutationInput, options?: StoreMutationOptions): Promise<MutationResult>;
-//# sourceMappingURL=mutation.d.ts.map

package/dist/store/mutation.js

@@ -32,4 +32,3 @@ export async function mutateStore(graph, memory, input, options = {}) {
         throw error;
     }
 }
-//# sourceMappingURL=mutation.js.map

package/dist/store/observe.d.ts

@@ -1,4 +1,3 @@
 import type { StoreQuery, StoreReadOptions, StoreSnapshot } from './store.js';
 import type { GraphStore } from './store.js';
 export declare function observeStore<Query extends StoreQuery>(store: GraphStore, query: Query, listener: (snapshot: StoreSnapshot<Query>) => void, options: StoreReadOptions): () => void;
-//# sourceMappingURL=observe.d.ts.map

package/dist/store/observe.js

@@ -15,4 +15,3 @@ export function observeStore(store, query, listener, options) {
     void store.read(admitted, options).catch(() => undefined);
     return unsubscribe;
 }
-//# sourceMappingURL=observe.js.map

package/dist/store/optimistic.d.ts

@@ -10,4 +10,3 @@ export declare class OptimisticOverlay {
     node(id: NodeId, entities: EntityIndex): Node | undefined;
     clear(): void;
 }
-//# sourceMappingURL=optimistic.d.ts.map

package/dist/store/optimistic.js

@@ -41,4 +41,3 @@ function nodeId(input) {
         ? path.ast.anchor.id
         : undefined;
 }
-//# sourceMappingURL=optimistic.js.map

package/dist/store/query-key.d.ts

@@ -1,6 +1,6 @@
 import type { QueryAST as QueryASTValue } from '@astrale-os/kernel-core/graph/query';
+import type { DomainDependency } from '@astrale-os/kernel-dsl/v1/schema';
 import type { QueryPageRequest } from '../graph/index.js';
 export declare function admitQuery(input: QueryASTValue): QueryASTValue;
 export declare function admitPage(input: QueryPageRequest): QueryPageRequest;
-export declare function queryKey(ast: QueryASTValue, page: QueryPageRequest): string;
-//# sourceMappingURL=query-key.d.ts.map
+export declare function queryKey(ast: QueryASTValue, page: QueryPageRequest, expected: readonly DomainDependency[] | undefined): string;

package/dist/store/query-key.js

@@ -17,7 +17,11 @@ export function admitPage(input) {
         ...(input.after === undefined ? {} : { after: input.after }),
     });
 }
-export function queryKey(ast, page) {
-    return JSON.stringify([QueryAST.fingerprint(ast), page.size, page.after ?? null]);
+export function queryKey(ast, page, expected) {
+    return JSON.stringify([
+        QueryAST.fingerprint(ast),
+        page.size,
+        page.after ?? null,
+        expected ?? null,
+    ]);
 }
-//# sourceMappingURL=query-key.js.map

package/dist/store/shape.d.ts

@@ -1,5 +1,6 @@
 import type { NodeId } from '@astrale-os/kernel-core/graph/node';
 import type { QueryAST } from '@astrale-os/kernel-core/graph/query';
+import type { DomainDependency } from '@astrale-os/kernel-dsl/v1/schema';
 import type { QueryPageRequest } from '../graph/index.js';
 import type { FactReferences } from './entity-index.js';
 import type { StoreQueryResponse, StoreSnapshot } from './store.js';
@@ -8,6 +9,7 @@ export declare class QueryShape {
     readonly key: string;
     readonly ast: QueryAST;
     readonly page: QueryPageRequest;
+    readonly expected: readonly DomainDependency[] | undefined;
     readonly listeners: Set<() => void>;
     state: ShapeState;
     confirmed?: StoreQueryResponse;
@@ -18,9 +20,8 @@ export declare class QueryShape {
     accessedAt: number;
     refreshedAt?: number;
     snapshot: StoreSnapshot;
-    constructor(key: string, ast: QueryAST, page: QueryPageRequest, now: number);
+    constructor(key: string, ast: QueryAST, page: QueryPageRequest, expected: readonly DomainDependency[] | undefined, now: number);
     get observed(): boolean;
     referencesAny(nodes: ReadonlySet<NodeId>, edges: ReadonlySet<string>): boolean;
 }
 export declare const COLD_SNAPSHOT: StoreSnapshot;
-//# sourceMappingURL=shape.d.ts.map

package/dist/store/shape.js

@@ -2,6 +2,7 @@ export class QueryShape {
     key;
     ast;
     page;
+    expected;
     listeners = new Set();
     state = 'cold';
     confirmed;
@@ -12,10 +13,11 @@ export class QueryShape {
     accessedAt;
     refreshedAt;
     snapshot = COLD_SNAPSHOT;
-    constructor(key, ast, page, now) {
+    constructor(key, ast, page, expected, now) {
         this.key = key;
         this.ast = ast;
         this.page = page;
+        this.expected = expected;
         this.accessedAt = now;
     }
     get observed() {
@@ -27,4 +29,3 @@ export class QueryShape {
     }
 }
 export const COLD_SNAPSHOT = Object.freeze({ state: 'cold' });
-//# sourceMappingURL=shape.js.map

package/dist/store/store.d.ts

@@ -1,14 +1,13 @@
 import type { MutationAST, MutationInput, MutationResult } from '@astrale-os/kernel-core/graph/mutate';
 import type { QueryAST, QueryResultFor } from '@astrale-os/kernel-core/graph/query';
 import type { QueryResponse } from '../graph/index.js';
-import type { GraphApi, GraphQueryOptions, MutationAuthor } from '../graph/index.js';
-import type { RequestOptions } from '../transport/index.js';
+import type { GraphApi, GraphMutationOptions, GraphQueryOptions, MutationAuthor } from '../graph/index.js';
 export type StoreQuery = QueryAST;
 export type StoreQueryResponse<Query extends StoreQuery = StoreQuery> = QueryResponse<QueryResultFor<Query>>;
 export interface StoreReadOptions extends GraphQueryOptions {
     readonly freshness?: 'cached' | 'refresh';
 }
-export interface StoreMutationOptions extends RequestOptions {
+export interface StoreMutationOptions extends GraphMutationOptions {
     readonly optimistic?: boolean;
 }
 export type StoreSnapshot<Query extends StoreQuery = StoreQuery> = {
@@ -66,4 +65,3 @@ export declare class GraphStore {
     private identity;
     private requireOpen;
 }
-//# sourceMappingURL=store.d.ts.map