@astrale-os/kernel-client 0.6.0-beta.1 → 0.6.0-beta.10

package/dist/session/session.d.ts

@@ -1,23 +1,22 @@
-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 { Input, Result } from '@astrale-os/kernel-ports/functions';
-import type { Call } from '../client/index.js';
+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 { 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 { ViewCatalog } from './views/index.js';
 export interface ClientSessionOptions {
-    /** Source Kernel invocation endpoint. */
-    readonly url: string;
-    /**
-     * Exact source Kernel identity when it is not represented by the root Publication discovered at
-     * the endpoint origin, as for a path-multiplexed managed child.
-     */
-    readonly sourceIssuer?: IssuerId;
+    /** Exact canonical source Kernel identity; its invocation and discovery endpoints are derived. */
+    readonly kernel: string;
     readonly fetch?: Fetch;
     readonly client?: ClientFactory;
     readonly pool?: Pick<ClientPoolType, 'clientFor'>;
@@ -31,9 +30,15 @@ export interface ClientSessionOptions {
     readonly maximumResponseBytes?: number;
     readonly timeoutMs?: number;
 }
-/** Caller-owned discovery and redirect-following conversation over one source invocation endpoint. */
-export declare class ClientSession {
+export type ConnectOptions = Omit<ClientSessionOptions, 'kernel' | 'policy'> & {
     readonly url: string;
+    readonly policy?: SessionPolicy;
+};
+/** 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;
@@ -43,14 +48,20 @@ 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>;
-    stream(call: Call, options?: SessionRequestOptions): Promise<import("@astrale-os/kernel-ports/functions").Stream>;
-    binary(call: Call, options?: SessionRequestOptions): Promise<import("@astrale-os/kernel-ports/functions").Binary>;
+    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/callable").BinaryResult>;
     close(): void;
     private requireOpen;
+    private invokeDomainMethod;
     private operation;
 }
-//# sourceMappingURL=session.d.ts.map
+/** Open one caller-owned conversation with a Kernel using secure defaults. */
+export declare function connect(options: ConnectOptions): ClientSession;

package/dist/session/session.js

@@ -1,17 +1,24 @@
-import { issuer as authIssuer } from '@astrale-os/kernel-core/auth';
+import { Path } from '@astrale-os/kernel-core/path';
 import { Client } from '../client/index.js';
-import { ClientError } from '../errors/index.js';
+import { ClientError, 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';
 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, endpoint, platformDuration, positive, } from './context/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';
-/** Caller-owned discovery and redirect-following conversation over one source invocation endpoint. */
+const DEFAULT_SESSION_POLICY = Object.freeze({ maximumRouteAgeMs: 60_000 });
+/** Caller-owned discovery and redirect-following conversation with one exact source Kernel. */
 export class ClientSession {
-    url;
+    kernel;
+    schema;
+    graph;
     ownedPool;
     discovery;
     dispatcher;
@@ -26,8 +33,8 @@ export class ClientSession {
         }
         const policy = admitPolicy(options.policy);
         this.admitTargetViews = (input) => targetViewCatalog(input, policy);
-        this.url = endpoint(options.url, policy.allowInsecureHttp === true);
-        const sourceIssuer = options.sourceIssuer === undefined ? undefined : authIssuer.accept(options.sourceIssuer);
+        this.kernel = admitKernel(options.kernel, policy.allowInsecureHttp === true);
+        const sourceEndpoint = kernelInvocationEndpoint(this.kernel);
         const fetch = options.fetch ?? globalThis.fetch;
         if (typeof fetch !== 'function')
             throw new TypeError('ClientSession requires Fetch.');
@@ -62,7 +69,7 @@ export class ClientSession {
             pool = admitClientPool(options.pool);
         }
         this.discovery = createSessionDiscovery({
-            url: this.url,
+            kernel: this.kernel,
             fetch: fetchImpl,
             policy,
             maximumPublicationBytes,
@@ -72,8 +79,8 @@ export class ClientSession {
         });
         this.routes = new RouteCache(policy.maximumRouteAgeMs);
         this.dispatcher = new SessionDispatcher({
-            url: this.url,
-            sourceIssuer,
+            kernel: this.kernel,
+            sourceEndpoint,
             pool,
             websocketAvailable,
             auth: admitSessionAuth(options.auth),
@@ -83,6 +90,15 @@ export class ClientSession {
             discovery: this.discovery,
             requireOpen: () => this.requireOpen(),
         });
+        this.schema = createSchema((request, options) => this.dispatch(request, options), {
+            maximumPublicationBytes,
+            maximumBundleBytes,
+        });
+        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)));
@@ -91,6 +107,23 @@ 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));
@@ -99,6 +132,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;
@@ -111,20 +159,47 @@ 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();
         return createSessionOperation(this.lifecycle.signal, options, this.timeoutMs);
     }
 }
+/** 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({
+        ...rest,
+        kernel: url,
+        policy: options.policy ?? DEFAULT_SESSION_POLICY,
+    });
+}
 function admitClientPool(input) {
     if (input === null ||
         typeof input !== 'object' ||
@@ -180,4 +255,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,18 +1,19 @@
-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,
             issuer: publication.identity.issuer,
@@ -25,7 +26,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 +49,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 +61,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

@@ -1,6 +1,5 @@
 import type { PathLike } from '@astrale-os/kernel-core/path';
-import type { Input } from '@astrale-os/kernel-ports/functions';
-import type { Call } from '../../client/index.js';
+import type { Call, Input } from '../../client/index.js';
 import type { SessionOperation } from '../context/index.js';
 import type { ViewCatalog } from './catalog.js';
 export type ViewInvoker = (call: Call, operation: SessionOperation) => Promise<Input>;
@@ -10,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,5 +1,5 @@
 import type { QueryAST } from '@astrale-os/kernel-core/graph/query';
-import type { QueryPageRequest } from '@astrale-os/kernel-ports/query';
+import type { QueryPageRequest } from '../graph/index.js';
 import type { GraphApi } from '../graph/index.js';
 import type { StoreQueryResponse, StoreReadOptions, StoreSnapshot } from './store.js';
 import { ClientError } from '../errors/index.js';
@@ -46,4 +46,3 @@ export declare class GraphMemory {
     private drain;
     private report;
 }
-//# sourceMappingURL=memory.d.ts.map

package/dist/store/memory.js

@@ -394,4 +394,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,5 @@
 import type { QueryAST as QueryASTValue } from '@astrale-os/kernel-core/graph/query';
-import type { QueryPageRequest } from '@astrale-os/kernel-ports/query';
+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

package/dist/store/query-key.js

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

package/dist/store/shape.d.ts

@@ -1,6 +1,6 @@
 import type { NodeId } from '@astrale-os/kernel-core/graph/node';
 import type { QueryAST } from '@astrale-os/kernel-core/graph/query';
-import type { QueryPageRequest } from '@astrale-os/kernel-ports/query';
+import type { QueryPageRequest } from '../graph/index.js';
 import type { FactReferences } from './entity-index.js';
 import type { StoreQueryResponse, StoreSnapshot } from './store.js';
 export type ShapeState = StoreSnapshot['state'];
@@ -23,4 +23,3 @@ export declare class QueryShape {
     referencesAny(nodes: ReadonlySet<NodeId>, edges: ReadonlySet<string>): boolean;
 }
 export declare const COLD_SNAPSHOT: StoreSnapshot;
-//# sourceMappingURL=shape.d.ts.map

package/dist/store/shape.js

@@ -27,4 +27,3 @@ export class QueryShape {
     }
 }
 export const COLD_SNAPSHOT = Object.freeze({ state: 'cold' });
-//# sourceMappingURL=shape.js.map

package/dist/store/store.d.ts

@@ -1,6 +1,6 @@
 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 '@astrale-os/kernel-ports/query';
+import type { QueryResponse } from '../graph/index.js';
 import type { GraphApi, GraphQueryOptions, MutationAuthor } from '../graph/index.js';
 import type { RequestOptions } from '../transport/index.js';
 export type StoreQuery = QueryAST;
@@ -66,4 +66,3 @@ export declare class GraphStore {
     private identity;
     private requireOpen;
 }
-//# sourceMappingURL=store.d.ts.map

package/dist/store/store.js

@@ -142,4 +142,3 @@ function positive(input, label) {
     }
     return input;
 }
-//# sourceMappingURL=store.js.map

package/dist/store/store.typecheck.d.ts

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

package/dist/store/store.typecheck.js

@@ -1,11 +1,11 @@
 import { Query } from '../graph/index.js';
 const options = { page: { size: 32 } };
-const nodeGraph = Query.from({ kind: 'node', paths: [path] }).select({ kind: 'graph' });
-const nodeProjection = Query.from({ kind: 'node', paths: [path] }).select({
+const nodeGraph = Query.from({ nodes: [path] }).select({ kind: 'graph' });
+const nodeProjection = Query.from({ nodes: [path] }).select({
     kind: 'nodes',
     projection: { kind: 'reference' },
 });
-const edgeSource = Query.from({ kind: 'edge', definitions: [edge] });
+const edgeSource = Query.from({ edges: [edge] });
 const edgeProjection = edgeSource.select({
     kind: 'edges',
     projection: { edge: 'reference', source: 'value', target: 'reference' },
@@ -38,4 +38,3 @@ store.observe(nodeGraph, () => undefined);
 // @ts-expect-error watch is reserved for a future remote-liveness protocol.
 store.watch(nodeGraph, () => undefined, options);
 void {};
-//# sourceMappingURL=store.typecheck.js.map

package/dist/transport/auto/decision.d.ts

@@ -20,4 +20,3 @@ export declare class AutoDecision {
     release(): void;
     close(): void;
 }
-//# sourceMappingURL=decision.d.ts.map

package/dist/transport/auto/decision.js

@@ -46,4 +46,3 @@ export class AutoDecision {
         this.pending = undefined;
     }
 }
-//# sourceMappingURL=decision.js.map

package/dist/transport/auto/fallback.d.ts

@@ -14,4 +14,3 @@ export declare class InvocationBudget {
 }
 export declare function mayFallback(error: unknown): error is TransportError;
 export declare function warningTarget(input: TransportRequest): TransportRequest['call']['target'];
-//# sourceMappingURL=fallback.d.ts.map

package/dist/transport/auto/fallback.js

@@ -1,4 +1,5 @@
 import { TransportError } from '../../errors/index.js';
+import { invocationFailure } from '../failure.js';
 import { positiveInteger } from '../index.js';
 const MAXIMUM_TIMEOUT_MS = 2_147_483_647;
 /** One invocation-owned total timeout budget shared by selection and fallback. */
@@ -33,10 +34,7 @@ export class InvocationBudget {
         let timer;
         let abort;
         const interrupted = new Promise((_resolve, reject) => {
-            timer = setTimeout(() => reject(new TransportError('Automatic transport decision exceeded its timeout.', {
-                phase: 'timeout',
-                delivery: 'not-sent',
-            })), remaining);
+            timer = setTimeout(() => reject(invocationFailure('Automatic transport decision exceeded its timeout.', 'timeout')), remaining);
             if (this.input?.signal) {
                 abort = () => reject(abortReason(this.input.signal));
                 this.input.signal.addEventListener('abort', abort, { once: true });
@@ -55,16 +53,17 @@ export class InvocationBudget {
     remaining() {
         const remaining = Math.min(MAXIMUM_TIMEOUT_MS, this.timeoutMs - (Date.now() - this.started));
         if (remaining < 1) {
-            throw new TransportError('Automatic transport invocation exceeded its timeout.', {
-                phase: 'timeout',
-                delivery: 'not-sent',
-            });
+            throw invocationFailure('Automatic transport invocation exceeded its timeout.', 'timeout');
         }
         return remaining;
     }
 }
 export function mayFallback(error) {
-    return error instanceof TransportError && error.phase !== 'closed' && error.phase !== 'timeout';
+    return (error instanceof TransportError &&
+        error.context.kind === 'invocation' &&
+        error.context.delivery === 'not-sent' &&
+        error.phase !== 'closed' &&
+        error.phase !== 'timeout');
 }
 export function warningTarget(input) {
     return input.call.target;
@@ -74,4 +73,3 @@ function abortReason(signal) {
         ? signal.reason
         : new Error(signal.reason === undefined ? 'request was cancelled' : String(signal.reason));
 }
-//# sourceMappingURL=fallback.js.map

package/dist/transport/auto/index.d.ts

@@ -1,3 +1,2 @@
 export { AutoTransport, type AutoTransportOptions } from './transport.js';
 export { formatClientWarning, type ClientWarning } from './warning.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/transport/auto/index.js

@@ -1,3 +1,2 @@
 export { AutoTransport } from './transport.js';
 export { formatClientWarning } from './warning.js';
-//# sourceMappingURL=index.js.map