@astrale-os/kernel-client 0.6.0-beta.3 → 0.6.0-beta.31

package/dist/session/routing/envelope.js

@@ -1,6 +1,19 @@
 import { ClientError } from '../../errors/index.js';
 import { allowEndpoint } from '../context/index.js';
 export function selectEnvelope(endpoints, preference, websocketAvailable, pool, policy) {
+    const destination = selectEnvelopeTarget(endpoints, preference, websocketAvailable, policy);
+    const client = pool.clientFor(destination);
+    if (client === null ||
+        typeof client !== 'object' ||
+        typeof client.dispatch !== 'function' ||
+        typeof client.as !== 'function' ||
+        typeof client.close !== 'function') {
+        throw new TypeError('Session client pool capability returned an invalid Client.');
+    }
+    return Object.freeze({ client, destination });
+}
+/** Resolve and admit one route endpoint without acquiring a transport Client. */
+export function selectEnvelopeTarget(endpoints, preference, websocketAvailable, policy) {
     let destination;
     if (preference === 'websocket') {
         if (endpoints.websocket === undefined) {
@@ -23,14 +36,5 @@ export function selectEnvelope(endpoints, preference, websocketAvailable, pool,
         allowEndpoint(endpoints.http, policy);
         destination = Object.freeze({ transport: 'http', url: endpoints.http });
     }
-    const client = pool.clientFor(destination);
-    if (client === null ||
-        typeof client !== 'object' ||
-        typeof client.dispatch !== 'function' ||
-        typeof client.as !== 'function' ||
-        typeof client.close !== 'function') {
-        throw new TypeError('Session client pool capability returned an invalid Client.');
-    }
-    return Object.freeze({ client, destination });
+    return destination;
 }
-//# sourceMappingURL=envelope.js.map

package/dist/session/routing/expectation.d.ts

@@ -0,0 +1,6 @@
+import type { Key, Revision } from '@astrale-os/kernel-dsl/v1';
+/** Private static-consumer expectation carried only by ClientSession.invoke. */
+export interface SchemaExpectation {
+    readonly origin: Key.Origin;
+    readonly revision: Revision;
+}

package/dist/session/routing/expectation.js

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

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

@@ -1,7 +1,6 @@
 export { admitSessionAuth, resolveAuth, type Auth, type EffectiveAuth, type SessionAuth, } from './auth.js';
-export type { BoundTarget } from './bound.js';
-export { RouteCache, type LearnedRoute } from './cache.js';
+export type { SchemaExpectation } from './expectation.js';
+export { RouteCache, type LearnedRoute, type PersistedRoute, type SessionRouteArtifact, type SessionRouteStore, } from './cache.js';
 export { requireResultKind, SessionDispatcher, type SessionDispatcherOptions } from './dispatch.js';
 export { type ClientPoolCapability, type EnvelopeSelection } from './envelope.js';
 export { admitEnvelopeTransport, admitRequestOptions, type SessionEnvelopeTransport, type SessionRequestOptions, } from './request.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/session/routing/index.js

@@ -1,6 +1,5 @@
 export { admitSessionAuth, resolveAuth, } from './auth.js';
-export { RouteCache } from './cache.js';
+export { RouteCache, } from './cache.js';
 export { requireResultKind, SessionDispatcher } from './dispatch.js';
 export {} from './envelope.js';
 export { admitEnvelopeTransport, admitRequestOptions, } from './request.js';
-//# sourceMappingURL=index.js.map

package/dist/session/routing/request.d.ts

@@ -1,4 +1,4 @@
-import type { invocation } from '@astrale-os/kernel-protocol';
+import type * as invocation from '@astrale-os/kernel-protocol/invocation';
 import type { SessionControlOptions } from '../context/index.js';
 export type SessionEnvelopeTransport = 'auto' | 'http' | 'websocket';
 export interface SessionRequestOptions extends SessionControlOptions {
@@ -6,4 +6,3 @@ export interface SessionRequestOptions extends SessionControlOptions {
 }
 export declare function admitRequestOptions(input?: SessionRequestOptions): Readonly<SessionRequestOptions>;
 export declare function admitEnvelopeTransport(input: SessionEnvelopeTransport): SessionEnvelopeTransport;
-//# sourceMappingURL=request.d.ts.map

package/dist/session/routing/request.js

@@ -1,4 +1,4 @@
-import { invocation as invocationProtocol } from '@astrale-os/kernel-protocol';
+import * as invocationProtocol from '@astrale-os/kernel-protocol/invocation';
 import { admitControlOptions } from '../context/index.js';
 export function admitRequestOptions(input = {}) {
     if (input === null || typeof input !== 'object' || Array.isArray(input)) {
@@ -23,4 +23,3 @@ export function admitEnvelopeTransport(input) {
     }
     return input;
 }
-//# sourceMappingURL=request.js.map

package/dist/session/session.d.ts

@@ -1,15 +1,17 @@
-import type { IssuerId } from '@astrale-os/kernel-core/auth';
+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 { SessionAuth, BoundTarget, SessionEnvelopeTransport, SessionRequestOptions } from './routing/index.js';
+import type { CallableReference, InputOfReference, OutputOfReference } from './reference.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. */
@@ -19,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,15 +31,15 @@ export interface ClientSessionOptions {
     readonly maximumResponseBytes?: number;
     readonly timeoutMs?: number;
 }
-export type ConnectOptions = Omit<ClientSessionOptions, 'policy'> & {
+export type ConnectOptions = Omit<ClientSessionOptions, 'kernel' | 'policy'> & {
+    readonly url: string;
     readonly policy?: SessionPolicy;
 };
-/** Package-private exact-Publication dispatch used by Domain bindings. */
-export declare function dispatchBound(session: ClientSession, call: Call, expected: BoundTarget, options?: SessionRequestOptions): Promise<Result>;
 /** Caller-owned discovery and redirect-following conversation with one exact source Kernel. */
 export declare class ClientSession {
     readonly kernel: IssuerId;
     readonly schema: SchemaApi;
+    readonly graph: GraphApi;
     private readonly ownedPool?;
     private readonly discovery;
     private readonly dispatcher;
@@ -45,17 +49,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>;
-    installed(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,5 +1,8 @@
+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 { AutoTransport } from '../transport/auto/index.js';
@@ -7,21 +10,15 @@ import { HttpTransport } from '../transport/http/index.js';
 import { WebSocketTransport } from '../transport/websocket/index.js';
 import { admitControlOptions, admitPolicy, createSessionOperation, DEFAULT_MAXIMUM_BUNDLE_BYTES, DEFAULT_MAXIMUM_PUBLICATION_BYTES, DEFAULT_MAXIMUM_RESPONSE_BYTES, DEFAULT_TIMEOUT_MS, admitKernel, kernelInvocationEndpoint, platformDuration, positive, } from './context/index.js';
 import { createSessionDiscovery } from './discovery/index.js';
+import { admitReference } from './reference.js';
 import { admitEnvelopeTransport, admitRequestOptions, admitSessionAuth, requireResultKind, RouteCache, SessionDispatcher, } from './routing/index.js';
 import { resolveViewsFor, targetViewCatalog } from './views/index.js';
 const DEFAULT_SESSION_POLICY = Object.freeze({ maximumRouteAgeMs: 60_000 });
-const boundDispatch = new WeakMap();
-/** Package-private exact-Publication dispatch used by Domain bindings. */
-export function dispatchBound(session, call, expected, options) {
-    const dispatch = boundDispatch.get(session);
-    if (dispatch === undefined)
-        throw new TypeError('Bound dispatch requires an owned ClientSession.');
-    return dispatch(call, expected, options);
-}
 /** Caller-owned discovery and redirect-following conversation with one exact source Kernel. */
 export class ClientSession {
     kernel;
     schema;
+    graph;
     ownedPool;
     discovery;
     dispatcher;
@@ -80,7 +77,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,
@@ -90,17 +87,17 @@ 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,
         });
-        boundDispatch.set(this, (request, expected, options) => {
-            const admitted = admitRequestOptions(options);
-            return this.dispatcher.dispatch(request, admitted, this.operation(admitted), expected);
-        });
+        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)));
@@ -109,23 +106,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 installed(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));
@@ -134,6 +114,21 @@ export class ClientSession {
         const result = await this.dispatch(call, options);
         return requireResultKind('value', result).value;
     }
+    async invoke(reference, input, options) {
+        const admittedReference = admitReference(reference);
+        const admittedOptions = admitRequestOptions(options);
+        const expected = Object.freeze({
+            origin: admittedReference.origin,
+            revision: admittedReference.revision,
+        });
+        const result = await this.dispatcher.dispatch({ target: admittedReference.target, input }, admittedOptions, this.operation(admittedOptions), expected);
+        const narrowed = requireResultKind(admittedReference.outputMode, result);
+        return (narrowed.kind === 'value'
+            ? narrowed.value
+            : narrowed.kind === 'stream'
+                ? narrowed.stream
+                : narrowed.value);
+    }
     async stream(call, options) {
         const result = await this.dispatch(call, options);
         return requireResultKind('stream', result).stream;
@@ -146,14 +141,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();
@@ -162,8 +172,13 @@ export class ClientSession {
 }
 /** Open one caller-owned conversation with a Kernel using secure defaults. */
 export function connect(options) {
+    if (options === null || typeof options !== 'object') {
+        throw new TypeError('Connect options are invalid.');
+    }
+    const { url, ...rest } = options;
     return new ClientSession({
-        ...options,
+        ...rest,
+        kernel: url,
         policy: options.policy ?? DEFAULT_SESSION_POLICY,
     });
 }
@@ -222,4 +237,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,23 @@ void envelope;
 void policy;
 void request;
 void snapshot;
+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);
 void {};
-//# sourceMappingURL=session.typecheck.js.map

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

@@ -1,9 +1,9 @@
 import type { Key, bundle } from '@astrale-os/kernel-dsl/v1';
 import type { publication } from '@astrale-os/kernel-protocol';
-import { syscalls } from '@astrale-os/kernel-core/schema';
+import { type ResolvedView } from '@astrale-os/kernel-core/schema/kernel/syscalls/view-resolution';
+export type { ResolvedView } from '@astrale-os/kernel-core/schema/kernel/syscalls/view-resolution';
 import type { SessionPolicy } from '../context/index.js';
 /** One verified View declaration joined with its owning Publication and provenance. */
-export type ResolvedView = syscalls.view.ResolvedView;
 /** Immutable canonical-key-ordered inventory of Views resolved under one Session revision. */
 export interface ViewCatalog {
     readonly entrypoint?: ResolvedView;
@@ -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 { syscalls } from '@astrale-os/kernel-core/schema';
-import { Key as ViewKey, Ref } from '@astrale-os/kernel-dsl/v1';
+import { acceptViewResolution, } from '@astrale-os/kernel-core/schema/kernel/syscalls/view-resolution';
+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.');
     }
@@ -48,7 +50,7 @@ export function catalogFromKeys(root, keys) {
 export function targetViewCatalog(input, policy) {
     let resolution;
     try {
-        resolution = syscalls.view.acceptResolution(input);
+        resolution = acceptViewResolution(input);
     }
     catch (cause) {
         throw new ClientError('Resolved View catalog is invalid.', { cause });
@@ -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

@@ -1,5 +1,5 @@
 import { Path } from '@astrale-os/kernel-core/path';
-import { K } from '@astrale-os/kernel-core/schema';
+import { view } from '@astrale-os/kernel-core/schema/kernel/syscalls/references';
 import { call } from '../../client/index.js';
 /**
  * Invoke Runtime-owned target View resolution through the canonical source Kernel call, then admit
@@ -7,6 +7,7 @@ import { call } from '../../client/index.js';
  */
 export async function resolveViewsFor(invoke, admitCatalog, target, operation) {
     const path = Path.from(target).raw;
-    return admitCatalog(await invoke(call(K.View.resolve.path, { target: path }), operation));
+    const owner = Path.project(view.resolve.owner);
+    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