@myko/core 6.1.0 → 6.3.0

package/dist/client.js

@@ -4,10 +4,12 @@
  * Maintains connections to all known servers for instant failover.
  * When the current server disconnects, instantly switches to another open connection.
  */
-import { GetPeerServers, MykoEvent, } from './generated';
 import { Decoder, Encoder } from 'cbor-x';
-import { bufferCount, bufferTime, catchError, combineLatest, filter, finalize, firstValueFrom, interval, map, merge, Observable, of, ReplaySubject, scan, shareReplay, Subject, switchMap, } from 'rxjs';
+import { bufferCount, bufferTime, catchError, combineLatest, distinctUntilChanged, filter, finalize, firstValueFrom, interval, map, merge, Observable, of, ReplaySubject, Subject, scan, shareReplay, switchMap, } from 'rxjs';
 import { v4 as uuid } from 'uuid';
+import { GetPeerServers, MykoEvent, } from './generated';
+import { bindGraph } from './graph-client.js';
+import { LiveCollection } from './live-collection.js';
 // cbor-x's defaults emit several non-standard extensions (the "records" structure
 // compression, tag 259 for maps with non-string keys, typed-array tags) that other
 // CBOR implementations — including the Rust server's `ciborium` decoder targeting
@@ -156,6 +158,77 @@ function reportCacheKey(report) {
     const payload = stableStringify(report.report) ?? '__unstable_report__';
     return `report:${report.reportId}:${payload}`;
 }
+/** One shared source subscription with direct fine-grained state listeners. */
+class LiveSelectionHub {
+    #source;
+    #onEmpty;
+    #registrations = new Set();
+    #state;
+    #sourceSubscription;
+    constructor(source, onEmpty) {
+        this.#source = source;
+        this.#onEmpty = onEmpty;
+    }
+    watch(register, equals = Object.is) {
+        return new Observable((subscriber) => {
+            let emitted = false;
+            let previous;
+            const emit = (value) => {
+                if (emitted && equals(previous, value))
+                    return;
+                emitted = true;
+                previous = value;
+                subscriber.next(value);
+            };
+            const registration = {
+                attach: (state) => {
+                    registration.detach = register(state, emit);
+                },
+                complete: () => subscriber.complete(),
+                error: (cause) => subscriber.error(cause),
+            };
+            this.#registrations.add(registration);
+            if (this.#state !== undefined)
+                registration.attach(this.#state);
+            if (!this.#sourceSubscription)
+                this.#start();
+            return () => {
+                registration.detach?.();
+                this.#registrations.delete(registration);
+                if (this.#registrations.size === 0) {
+                    this.#sourceSubscription?.unsubscribe();
+                    this.#sourceSubscription = undefined;
+                    this.#state = undefined;
+                    this.#onEmpty();
+                }
+            };
+        });
+    }
+    #start() {
+        const subscription = this.#source().subscribe({
+            next: (state) => {
+                if (this.#state === state)
+                    return;
+                this.#state = state;
+                for (const registration of this.#registrations) {
+                    registration.detach?.();
+                    registration.attach(state);
+                }
+            },
+            error: (cause) => {
+                for (const registration of [...this.#registrations]) {
+                    registration.error(cause);
+                }
+            },
+            complete: () => {
+                for (const registration of [...this.#registrations]) {
+                    registration.complete();
+                }
+            },
+        });
+        this.#sourceSubscription = subscription.closed ? undefined : subscription;
+    }
+}
 /**
  * Reactive WebSocket client for Myko servers with automatic failover.
  */
@@ -187,6 +260,7 @@ export class MykoClient {
     queryErrorRoutes = new Map();
     viewErrorRoutes = new Map();
     reportErrorRoutes = new Map();
+    pendingCommands = new Map();
     // Lighter-weight direct-callback routing for `subscribeReport` — avoids
     // allocating an RxJS Subject per anchor when the consumer just needs a
     // single callback (which is the case for liveReport in the Svelte runtime).
@@ -197,6 +271,7 @@ export class MykoClient {
     currentServerSubject = new ReplaySubject(1);
     // Subscription tracking
     activeQueries = new Map();
+    activeQueryCursorWindows = new Map();
     activeViews = new Map();
     activeReports = new Map();
     activeQueryNames = new Map();
@@ -204,8 +279,14 @@ export class MykoClient {
     activeReportNames = new Map();
     sharedQueries = new Map();
     sharedViews = new Map();
+    sharedQueryResponseStreams = new Map();
+    sharedViewResponseStreams = new Map();
     sharedQueryDiffs = new Map();
     sharedViewDiffs = new Map();
+    sharedQueryStates = new Map();
+    sharedViewStates = new Map();
+    querySelectionHubs = new Map();
+    viewSelectionHubs = new Map();
     sharedReports = new Map();
     subscriptionStartMs = new Map();
     firstResponseLogged = new Set();
@@ -456,6 +537,7 @@ export class MykoClient {
                 activeQueriesBefore: this.activeQueries.size,
             });
             this.activeQueries.delete(tx);
+            this.activeQueryCursorWindows.delete(tx);
             this.activeQueryNames.delete(tx);
             this.subscriptionStartMs.delete(tx);
             this.firstResponseLogged.delete(tx);
@@ -467,6 +549,29 @@ export class MykoClient {
         }));
         return [tx, responses$];
     }
+    /**
+     * One ref-counted wire stream per immutable query identity.
+     *
+     * Array, diff, and keyed-state projections all consume this stream. Keeping
+     * the cache below those projections prevents the same query from opening
+     * several server subscriptions merely because different UI layers prefer
+     * different result shapes.
+     */
+    sharedQueryResponses(query, options) {
+        const cacheKey = queryCacheKey(query, options);
+        const existing = this.sharedQueryResponseStreams.get(cacheKey);
+        if (existing)
+            return existing;
+        const [, responses$] = this.startQuery(query, options);
+        let shared$;
+        shared$ = responses$.pipe(finalize(() => {
+            if (this.sharedQueryResponseStreams.get(cacheKey) === shared$) {
+                this.sharedQueryResponseStreams.delete(cacheKey);
+            }
+        }), shareReplay({ bufferSize: 1, refCount: true }));
+        this.sharedQueryResponseStreams.set(cacheKey, shared$);
+        return shared$;
+    }
     /** Update server-side window for an active query subscription */
     setQueryWindow(tx, window) {
         const active = this.activeQueries.get(tx);
@@ -489,6 +594,19 @@ export class MykoClient {
         });
         this.send({ event: MykoEvent.QueryWindow, data: { tx, window } });
     }
+    /** Move an active query to an exclusive ID-keyset page. */
+    setQueryCursorWindow(tx, window) {
+        if (window.after !== undefined && window.before !== undefined) {
+            throw new Error('cursor window cannot contain both after and before');
+        }
+        if (!this.activeQueries.has(tx))
+            return;
+        this.activeQueryCursorWindows.set(tx, window);
+        this.send({
+            event: 'ws:m:query-cursor-window',
+            data: { tx, window },
+        });
+    }
     /** Start a view subscription, returns [tx, responses$] */
     startView(view, options) {
         if (!view.viewId || !view.viewItemType || !view.view) {
@@ -558,6 +676,22 @@ export class MykoClient {
         }));
         return [tx, responses$];
     }
+    /** One ref-counted wire stream shared by every immutable view projection. */
+    sharedViewResponses(view, options) {
+        const cacheKey = viewCacheKey(view, options);
+        const existing = this.sharedViewResponseStreams.get(cacheKey);
+        if (existing)
+            return existing;
+        const [, responses$] = this.startView(view, options);
+        let shared$;
+        shared$ = responses$.pipe(finalize(() => {
+            if (this.sharedViewResponseStreams.get(cacheKey) === shared$) {
+                this.sharedViewResponseStreams.delete(cacheKey);
+            }
+        }), shareReplay({ bufferSize: 1, refCount: true }));
+        this.sharedViewResponseStreams.set(cacheKey, shared$);
+        return shared$;
+    }
     /** Update server-side window for an active view subscription */
     setViewWindow(tx, window) {
         const active = this.activeViews.get(tx);
@@ -585,7 +719,7 @@ export class MykoClient {
         const existing = this.sharedQueries.get(cacheKey);
         if (existing)
             return existing;
-        const [, responses$] = this.startQuery(query, options);
+        const responses$ = this.sharedQueryResponses(query, options);
         const shared$ = responses$.pipe(scan((acc, update) => {
             if (BigInt(update.data.sequence) === 0n)
                 acc.clear();
@@ -613,7 +747,7 @@ export class MykoClient {
         const existing = this.sharedViews.get(cacheKey);
         if (existing)
             return existing;
-        const [, responses$] = this.startView(view, options);
+        const responses$ = this.sharedViewResponses(view, options);
         const shared$ = responses$.pipe(scan((acc, update) => {
             if (BigInt(update.data.sequence) === 0n)
                 acc.clear();
@@ -637,7 +771,7 @@ export class MykoClient {
         const existing = this.sharedQueryDiffs.get(cacheKey);
         if (existing)
             return existing;
-        const [, responses$] = this.startQuery(query, options);
+        const responses$ = this.sharedQueryResponses(query, options);
         const shared$ = responses$.pipe(map((r) => ({
             sequence: BigInt(r.data.sequence),
             deletes: r.data.deletes.slice(),
@@ -658,7 +792,7 @@ export class MykoClient {
         const existing = this.sharedViewDiffs.get(cacheKey);
         if (existing)
             return existing;
-        const [, responses$] = this.startView(view, options);
+        const responses$ = this.sharedViewResponses(view, options);
         const shared$ = responses$.pipe(map((r) => ({
             sequence: BigInt(r.data.sequence),
             deletes: r.data.deletes.slice(),
@@ -673,6 +807,108 @@ export class MykoClient {
         this.sharedViewDiffs.set(cacheKey, shared$);
         return shared$;
     }
+    /**
+     * Watch a query as stable keyed state without rebuilding its full result array.
+     *
+     * Identical requests share both the wire subscription and collection instance.
+     * Use `toArray()` only where array rendering is required; `get()`, `items`, and
+     * `changes` remain O(changes) for incremental updates.
+     */
+    watchQueryState(query, options) {
+        const cacheKey = queryCacheKey(query, options);
+        const existing = this.sharedQueryStates.get(cacheKey);
+        if (existing)
+            return existing;
+        const state = new LiveCollection();
+        const shared$ = this.watchQueryDiff(query, options).pipe(map((diff) => state.apply(diff)), catchError((error) => of(state.fail(error))), finalize(() => {
+            this.sharedQueryStates.delete(cacheKey);
+        }), shareReplay({ bufferSize: 1, refCount: true }));
+        this.sharedQueryStates.set(cacheKey, shared$);
+        return shared$;
+    }
+    /** Watch a view as stable keyed state without full-array reconstruction. */
+    watchViewState(view, options) {
+        const cacheKey = viewCacheKey(view, options);
+        const existing = this.sharedViewStates.get(cacheKey);
+        if (existing)
+            return existing;
+        const state = new LiveCollection();
+        const shared$ = this.watchViewDiff(view, options).pipe(map((diff) => state.apply(diff)), catchError((error) => of(state.fail(error))), finalize(() => {
+            this.sharedViewStates.delete(cacheKey);
+        }), shareReplay({ bufferSize: 1, refCount: true }));
+        this.sharedViewStates.set(cacheKey, shared$);
+        return shared$;
+    }
+    /**
+     * Watch an immutable projection of keyed query state.
+     *
+     * The underlying query/state subscription remains shared. The selector runs
+     * once per source revision, while equal results suppress downstream work.
+     * Select scalars, entity references, or newly-created immutable values; do
+     * not return `state.items` directly because that Map is intentionally stable
+     * and mutates in place.
+     */
+    watchQuerySelection(query, select, options) {
+        return this.watchQueryState(query, options).pipe(map(select), distinctUntilChanged(options?.equals ?? Object.is));
+    }
+    /** Watch one query result by ID without reacting to unrelated rows. */
+    watchQueryItem(query, id, options) {
+        return this.querySelectionHub(query, options).watch((state, emit) => state.subscribeItem(id, emit));
+    }
+    /** Watch membership of one ID without reacting to unrelated rows. */
+    watchQueryHas(query, id, options) {
+        return this.querySelectionHub(query, options).watch((state, emit) => state.subscribeItem(id, (item) => emit(item !== undefined)));
+    }
+    /** Watch live query cardinality without materializing its result array. */
+    watchQuerySize(query, options) {
+        return this.querySelectionHub(query, options).watch((state, emit) => state.subscribeSize(emit));
+    }
+    /** Watch an immutable projection of keyed view state. */
+    watchViewSelection(view, select, options) {
+        return this.watchViewState(view, options).pipe(map(select), distinctUntilChanged(options?.equals ?? Object.is));
+    }
+    /** Watch one view result by ID without reacting to unrelated rows. */
+    watchViewItem(view, id, options) {
+        return this.viewSelectionHub(view, options).watch((state, emit) => state.subscribeItem(id, emit));
+    }
+    /** Watch membership of one view ID without reacting to unrelated rows. */
+    watchViewHas(view, id, options) {
+        return this.viewSelectionHub(view, options).watch((state, emit) => state.subscribeItem(id, (item) => emit(item !== undefined)));
+    }
+    /** Watch live view cardinality without materializing its result array. */
+    watchViewSize(view, options) {
+        return this.viewSelectionHub(view, options).watch((state, emit) => state.subscribeSize(emit));
+    }
+    querySelectionHub(query, options) {
+        const cacheKey = queryCacheKey(query, options);
+        const existing = this.querySelectionHubs.get(cacheKey);
+        if (existing) {
+            return existing;
+        }
+        let hub;
+        hub = new LiveSelectionHub(() => this.watchQueryState(query, options), () => {
+            if (this.querySelectionHubs.get(cacheKey) === hub) {
+                this.querySelectionHubs.delete(cacheKey);
+            }
+        });
+        this.querySelectionHubs.set(cacheKey, hub);
+        return hub;
+    }
+    viewSelectionHub(view, options) {
+        const cacheKey = viewCacheKey(view, options);
+        const existing = this.viewSelectionHubs.get(cacheKey);
+        if (existing) {
+            return existing;
+        }
+        let hub;
+        hub = new LiveSelectionHub(() => this.watchViewState(view, options), () => {
+            if (this.viewSelectionHubs.get(cacheKey) === hub) {
+                this.viewSelectionHubs.delete(cacheKey);
+            }
+        });
+        this.viewSelectionHubs.set(cacheKey, hub);
+        return hub;
+    }
     /**
      * Start a live query with a mutable server-side window.
      * Use `setWindow` to scroll without re-subscribing.
@@ -731,6 +967,38 @@ export class MykoClient {
             setWindow: (window) => this.setQueryWindow(tx, window),
         };
     }
+    /** Start a live query whose subsequent pages use stable ID keysets. */
+    watchQueryCursor(query, limit, options) {
+        const watch = this.watchQueryWindowed(query, {
+            ...options,
+            window: { offset: 0, limit },
+        });
+        let requested = { limit };
+        const pageInfo$ = combineLatest([watch.results$, watch.windowInfo$]).pipe(map(([items, info]) => {
+            const rows = items;
+            const startCursor = rows.at(0)?.id ?? null;
+            const endCursor = rows.at(-1)?.id ?? null;
+            return {
+                totalCount: info.totalCount,
+                startCursor,
+                endCursor,
+                hasPreviousPage: requested.before !== undefined || requested.after !== undefined,
+                hasNextPage: rows.length === requested.limit &&
+                    (info.totalCount === null || rows.length < info.totalCount),
+            };
+        }), shareReplay({ bufferSize: 1, refCount: true }));
+        const setWindow = (window) => {
+            requested = window;
+            this.setQueryCursorWindow(watch.tx, window);
+        };
+        return {
+            tx: watch.tx,
+            results$: watch.results$,
+            pageInfo$,
+            setWindow,
+            firstPage: () => setWindow({ limit }),
+        };
+    }
     /** Start a live view with a mutable server-side window. */
     watchViewWindowed(view, options) {
         const [tx, responses$] = this.startView(view, options);
@@ -932,7 +1200,16 @@ export class MykoClient {
         this.scheduleEventBatchFlush();
     }
     /** Send a command and wait for response */
-    sendCommand(command) {
+    sendCommand(command, options = {}) {
+        if (options.timeoutMs !== undefined &&
+            (!Number.isFinite(options.timeoutMs) || options.timeoutMs < 0)) {
+            return Promise.reject(new RangeError('Command timeoutMs must be a finite non-negative number'));
+        }
+        if (options.signal?.aborted) {
+            const error = new Error('Command aborted before it was sent');
+            error.name = 'AbortError';
+            return Promise.reject(error);
+        }
         const tx = uuid();
         const wrappedCommand = {
             command: {
@@ -944,25 +1221,55 @@ export class MykoClient {
             commandId: command.commandId,
         };
         return new Promise((resolve, reject) => {
-            const responseSub = this.commandResponses
-                .pipe(filter((r) => r.data.tx === tx))
-                .subscribe((r) => {
-                cleanup();
-                resolve(r.data.response);
-            });
-            const errorSub = this.commandErrors
-                .pipe(filter((r) => r.data.tx === tx))
-                .subscribe((r) => {
-                cleanup();
-                reject(new Error(r.data.message));
-            });
-            const cleanup = () => {
-                responseSub.unsubscribe();
-                errorSub.unsubscribe();
+            let timeout;
+            const onAbort = () => {
+                const error = new Error('Command aborted');
+                error.name = 'AbortError';
+                fail(error);
+            };
+            const cleanup = (removeQueuedCommand = false) => {
+                this.pendingCommands.delete(tx);
+                if (timeout !== undefined)
+                    clearTimeout(timeout);
+                options.signal?.removeEventListener('abort', onAbort);
+                if (removeQueuedCommand && this.messageQueue.length > 0) {
+                    this.messageQueue = this.messageQueue.filter((message) => this.messageTx(message) !== tx);
+                }
+            };
+            const fail = (error) => {
+                cleanup(true);
+                reject(error);
             };
-            this.send({ event: MykoEvent.Command, data: wrappedCommand });
+            this.pendingCommands.set(tx, {
+                resolve: (message) => {
+                    cleanup();
+                    resolve(message.data.response);
+                },
+                reject: fail,
+            });
+            options.signal?.addEventListener('abort', onAbort, { once: true });
+            if (options.timeoutMs !== undefined) {
+                timeout = setTimeout(() => {
+                    const error = new Error(`Command timed out after ${options.timeoutMs}ms`);
+                    error.name = 'TimeoutError';
+                    fail(error);
+                }, options.timeoutMs);
+            }
+            try {
+                this.send({ event: MykoEvent.Command, data: wrappedCommand });
+            }
+            catch (error) {
+                fail(error instanceof Error ? error : new Error(String(error)));
+            }
         });
     }
+    /**
+     * Bind a generated `*Graph` descriptor into endpoint-scoped live state,
+     * aggregate, and mutation helpers.
+     */
+    graph(graph) {
+        return bindGraph(this, graph);
+    }
     // ─────────────────────────────────────────────────────────────────────────────
     // Private: Socket Management
     // ─────────────────────────────────────────────────────────────────────────────
@@ -1009,6 +1316,7 @@ export class MykoClient {
         return loopback.has(a) && loopback.has(b);
     }
     closeAllSockets() {
+        this.failPendingCommands(new Error('Disconnected before command completion'));
         for (const timer of this.reconnectTimers.values())
             clearTimeout(timer);
         this.reconnectTimers.clear();
@@ -1071,6 +1379,7 @@ export class MykoClient {
             this.sockets.delete(address);
             this.endpointSockets.delete(endpointKey);
             if (this.currentServer === address) {
+                this.failPendingCommands(new Error(`Connection closed before command completion: ${address}`));
                 const next = this.getFirstOpenSocket();
                 if (next) {
                     this.setCurrentServer(next.address, `failover from ${address} to ${next.address}`);
@@ -1216,9 +1525,15 @@ export class MykoClient {
                 this.reportResponses.next(message);
                 break;
             case MykoEvent.CommandResponse:
+                this.pendingCommands
+                    .get(message.data.tx)
+                    ?.resolve(message);
                 this.commandResponses.next(message);
                 break;
             case MykoEvent.CommandError:
+                this.pendingCommands
+                    .get(message.data.tx)
+                    ?.reject(new Error(message.data.message));
                 this.commandErrors.next(message);
                 break;
             case MykoEvent.QueryError:
@@ -1291,9 +1606,16 @@ export class MykoClient {
         }
         this.sendNow(message);
     }
+    failPendingCommands(error) {
+        for (const pending of [...this.pendingCommands.values()]) {
+            pending.reject(error);
+        }
+    }
     messageTx(message) {
         const data = message.data;
-        return typeof data?.tx === 'string' ? data.tx : null;
+        if (typeof data?.tx === 'string')
+            return data.tx;
+        return typeof data?.command?.tx === 'string' ? data.command.tx : null;
     }
     sendNow(message) {
         const event = message.event;
@@ -1347,11 +1669,18 @@ export class MykoClient {
         return query;
     }
     resendSubscriptions() {
-        for (const q of this.activeQueries.values()) {
+        for (const [tx, q] of this.activeQueries) {
             this.send({
                 event: MykoEvent.Query,
                 data: this.withReconnectSequenceReset(q),
             });
+            const cursor = this.activeQueryCursorWindows.get(tx);
+            if (cursor) {
+                this.send({
+                    event: 'ws:m:query-cursor-window',
+                    data: { tx, window: cursor },
+                });
+            }
         }
         for (const v of this.activeViews.values()) {
             this.send({ event: MykoEvent.View, data: v });

package/dist/generated/AdjacencyPolicy.d.ts

@@ -0,0 +1,2 @@
+export type AdjacencyPolicy = "demandDriven" | "eager";
+//# sourceMappingURL=AdjacencyPolicy.d.ts.map

package/dist/generated/AdjacencyPolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdjacencyPolicy.d.ts","sourceRoot":"","sources":["../../src/generated/AdjacencyPolicy.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,eAAe,GAAG,cAAc,GAAG,OAAO,CAAC"}

package/dist/generated/AdjacencyPolicy.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/Direction.d.ts

@@ -0,0 +1,2 @@
+export type Direction = "forward" | "reverse" | "both";
+//# sourceMappingURL=Direction.d.ts.map

package/dist/generated/Direction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Direction.d.ts","sourceRoot":"","sources":["../../src/generated/Direction.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC"}

package/dist/generated/Direction.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/EdgeShapeKind.d.ts

@@ -0,0 +1,2 @@
+export type EdgeShapeKind = "directed" | "undirected";
+//# sourceMappingURL=EdgeShapeKind.d.ts.map

package/dist/generated/EdgeShapeKind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EdgeShapeKind.d.ts","sourceRoot":"","sources":["../../src/generated/EdgeShapeKind.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,YAAY,CAAC"}

package/dist/generated/EdgeShapeKind.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/EndPosition.d.ts

@@ -0,0 +1,2 @@
+export type EndPosition = "a" | "b";
+//# sourceMappingURL=EndPosition.d.ts.map

package/dist/generated/EndPosition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EndPosition.d.ts","sourceRoot":"","sources":["../../src/generated/EndPosition.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,WAAW,GAAG,GAAG,GAAG,GAAG,CAAC"}

package/dist/generated/EndPosition.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/EndpointDeletePolicy.d.ts

@@ -0,0 +1,2 @@
+export type EndpointDeletePolicy = "cascadeEdge" | "restrictEndpointDelete" | "retainDangling";
+//# sourceMappingURL=EndpointDeletePolicy.d.ts.map

package/dist/generated/EndpointDeletePolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EndpointDeletePolicy.d.ts","sourceRoot":"","sources":["../../src/generated/EndpointDeletePolicy.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,oBAAoB,GAAG,aAAa,GAAG,wBAAwB,GAAG,gBAAgB,CAAC"}

package/dist/generated/EndpointDeletePolicy.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/EntityRef.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A stable, serializable reference to any registered Myko item.
+ */
+export type EntityRef = {
+    entityType: string;
+    id: string;
+};
+//# sourceMappingURL=EntityRef.d.ts.map

package/dist/generated/EntityRef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityRef.d.ts","sourceRoot":"","sources":["../../src/generated/EntityRef.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;CAAE,CAAC"}

package/dist/generated/EntityRef.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/GraphPlanTelemetry.d.ts

@@ -0,0 +1,16 @@
+import type { AdjacencyPolicy } from "./AdjacencyPolicy";
+import type { EndPosition } from "./EndPosition";
+/**
+ * Observed endpoint-query work and an actionable projection recommendation.
+ */
+export type GraphPlanTelemetry = {
+    edgeType: string;
+    position: EndPosition;
+    policy: AdjacencyPolicy;
+    lookups: bigint;
+    scannedEdges: bigint;
+    returnedEdges: bigint;
+    recommendEager: boolean;
+    reason: string;
+};
+//# sourceMappingURL=GraphPlanTelemetry.d.ts.map

package/dist/generated/GraphPlanTelemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphPlanTelemetry.d.ts","sourceRoot":"","sources":["../../src/generated/GraphPlanTelemetry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,eAAe,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;CAAE,CAAC"}

package/dist/generated/GraphPlanTelemetry.js

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

package/dist/generated/GraphSyncResult.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Summary returned by an authoritative endpoint reconciliation.
+ */
+export type GraphSyncResult = {
+    inserted: number;
+    updated: number;
+    deleted: number;
+    unchanged: number;
+};
+//# sourceMappingURL=GraphSyncResult.d.ts.map

package/dist/generated/GraphSyncResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphSyncResult.d.ts","sourceRoot":"","sources":["../../src/generated/GraphSyncResult.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;CAAE,CAAC"}

package/dist/generated/GraphSyncResult.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};