@hops-ops/distributed 0.0.0

package/dist/replica/distributed-replica/index.d.ts

@@ -0,0 +1,2 @@
+import type { DistributedReplica as DistributedReplicaApi, DistributedReplicaOptions } from '../types.js';
+export declare function createDistributedReplica(options?: DistributedReplicaOptions): DistributedReplicaApi;

package/dist/replica/distributed-replica/index.js

@@ -0,0 +1,4 @@
+import { DistributedReplicaImpl } from './impl.js';
+export function createDistributedReplica(options = {}) {
+    return new DistributedReplicaImpl(options);
+}

package/dist/replica/distributed-replica/optimistic.d.ts

@@ -0,0 +1,30 @@
+import { type CacheValue, type OptimisticCacheWriter, type RecordLink } from '../../internal/cache-engine.js';
+import type { DistributedCommandMetadata, DistributedOpaqueString } from '../../protocol.js';
+import type { ReplicaIndexSemanticChange } from '../index-maintenance.js';
+import type { ReplicaOptimisticWriter, ReplicaRecordPatch } from '../types.js';
+import type { CapturedReplicaOptimisticOperation, CapturedReplicaOptimisticUpdate, OptimisticReceiptState } from './types.js';
+export declare function optimisticReceiptState(command: DistributedCommandMetadata): OptimisticReceiptState;
+export declare function cloneOptimisticReceipt(receipt: OptimisticReceiptState): OptimisticReceiptState;
+export declare function sameReceipt(left: OptimisticReceiptState, right: OptimisticReceiptState): boolean;
+export declare function diagnosticReceiptExpectations(receipt: OptimisticReceiptState): readonly {
+    readonly projection: string;
+    readonly model: string;
+    readonly observed: boolean;
+}[];
+export declare function diagnosticReceiptCounts(receipt: OptimisticReceiptState | undefined): Readonly<{
+    obligations: number;
+    observed: number;
+}>;
+export declare function expectationKey(value: {
+    readonly projection: string;
+    readonly model: string;
+    readonly scopeToken: DistributedOpaqueString;
+}): string;
+export declare function captureReplicaOptimisticUpdate(id: string, update: (writer: ReplicaOptimisticWriter) => void, semanticChanges: readonly ReplicaIndexSemanticChange[]): CapturedReplicaOptimisticUpdate;
+export declare function replayReplicaOptimisticUpdate(writer: OptimisticCacheWriter, operations: readonly CapturedReplicaOptimisticOperation[]): void;
+export declare function cloneOptimisticFields(fields: ReplicaRecordPatch['fields']): Readonly<Record<string, CacheValue>>;
+export declare function cloneOptimisticLinks(links: ReplicaRecordPatch['links']): Readonly<Record<string, RecordLink>>;
+export declare function assertPlainReplicaRecord(value: object, description: string): void;
+export declare function assertReplicaOptimisticLayerId(id: string): void;
+export declare function assertReplicaName(value: string, description: string): void;
+export declare function assertReplicaOptimisticUpdateSynchronous(result: unknown): void;

package/dist/replica/distributed-replica/optimistic.js

@@ -0,0 +1,221 @@
+import {} from '../../internal/cache-engine.js';
+import { cloneJsonValue, replicaRecordKey } from '../identity.js';
+import { protocolInvalid } from './clocks.js';
+import { indexKeyFromTarget, metadataFromTarget } from './helpers.js';
+export function optimisticReceiptState(command) {
+    const expectations = new Map();
+    for (const expectation of command.expects) {
+        const key = expectationKey(expectation);
+        if (expectations.has(key)) {
+            protocolInvalid('extensions.distributed.command.expects');
+        }
+        expectations.set(key, true);
+    }
+    const observed = new Set();
+    for (const observation of command.observations) {
+        if (observation.causationId !== command.causationId) {
+            protocolInvalid('extensions.distributed.command.observations');
+        }
+        const key = expectationKey(observation);
+        if (!expectations.has(key)) {
+            protocolInvalid('extensions.distributed.command.observations');
+        }
+        observed.add(key);
+    }
+    return {
+        causationId: command.causationId,
+        expectations,
+        observed
+    };
+}
+export function cloneOptimisticReceipt(receipt) {
+    return {
+        causationId: receipt.causationId,
+        expectations: new Map(receipt.expectations),
+        observed: new Set(receipt.observed)
+    };
+}
+export function sameReceipt(left, right) {
+    return (left.causationId === right.causationId &&
+        left.expectations.size === right.expectations.size &&
+        [...left.expectations.keys()].every((key) => right.expectations.has(key)));
+}
+export function diagnosticReceiptExpectations(receipt) {
+    return Object.freeze([...receipt.expectations.keys()]
+        .map((key) => {
+        const parsed = JSON.parse(key);
+        if (!Array.isArray(parsed) ||
+            parsed.length !== 3 ||
+            typeof parsed[0] !== 'string' ||
+            typeof parsed[1] !== 'string') {
+            throw new TypeError('invalid internal projection expectation');
+        }
+        return Object.freeze({
+            projection: parsed[0],
+            model: parsed[1],
+            observed: receipt.observed.has(key)
+        });
+    })
+        .sort((left, right) => `${left.projection}\0${left.model}`.localeCompare(`${right.projection}\0${right.model}`)));
+}
+export function diagnosticReceiptCounts(receipt) {
+    return Object.freeze({
+        obligations: receipt?.expectations.size ?? 0,
+        observed: receipt?.observed.size ?? 0
+    });
+}
+export function expectationKey(value) {
+    return JSON.stringify([value.projection, value.model, value.scopeToken]);
+}
+export function captureReplicaOptimisticUpdate(id, update, semanticChanges) {
+    if (!Array.isArray(semanticChanges)) {
+        throw new TypeError('optimistic semantic changes must be an array');
+    }
+    const suppliedChanges = cloneJsonValue(semanticChanges);
+    const operations = [];
+    const changes = [];
+    let active = true;
+    const assertActive = () => {
+        if (!active)
+            throw new Error('replica optimistic writer is no longer active');
+    };
+    const writer = Object.freeze({
+        writeRecord(model, identity, patch) {
+            assertActive();
+            const key = replicaRecordKey(model, identity);
+            const fields = cloneOptimisticFields(patch.fields);
+            const links = cloneOptimisticLinks(patch.links);
+            if (Object.keys(fields).length === 0 && Object.keys(links).length === 0) {
+                return;
+            }
+            operations.push(Object.freeze({
+                kind: 'write-record',
+                write: Object.freeze({ key, fields, links })
+            }));
+            changes.push(Object.freeze({
+                kind: 'upsert',
+                model: model.id,
+                key,
+                fields
+            }));
+        },
+        tombstoneRecord(model, identity) {
+            assertActive();
+            const key = replicaRecordKey(model, identity);
+            operations.push(Object.freeze({ kind: 'tombstone-record', key }));
+            changes.push(Object.freeze({
+                kind: 'delete',
+                model: model.id,
+                key
+            }));
+        },
+        writeIndex(target, records) {
+            assertActive();
+            if (!Array.isArray(records)) {
+                throw new TypeError('index records must be an array');
+            }
+            const metadata = cloneJsonValue(metadataFromTarget(target));
+            operations.push(Object.freeze({
+                kind: 'write-index',
+                write: Object.freeze({
+                    key: indexKeyFromTarget(target),
+                    records: Object.freeze([...records]),
+                    complete: target.complete ?? false,
+                    metadata
+                })
+            }));
+        },
+        deleteIndex(target) {
+            assertActive();
+            operations.push(Object.freeze({
+                kind: 'delete-index',
+                key: indexKeyFromTarget(target)
+            }));
+        }
+    });
+    try {
+        const result = update(writer);
+        assertReplicaOptimisticUpdateSynchronous(result);
+    }
+    finally {
+        active = false;
+    }
+    changes.push(...suppliedChanges);
+    return Object.freeze({
+        operations: Object.freeze(operations),
+        context: cloneJsonValue({
+            id,
+            changes
+        })
+    });
+}
+export function replayReplicaOptimisticUpdate(writer, operations) {
+    for (const operation of operations) {
+        if (operation.kind === 'write-record') {
+            writer.writeRecord(operation.write);
+        }
+        else if (operation.kind === 'tombstone-record') {
+            writer.tombstoneRecord(operation.key);
+        }
+        else if (operation.kind === 'write-index') {
+            writer.writeIndex(operation.write);
+        }
+        else {
+            writer.deleteIndex(operation.key);
+        }
+    }
+}
+export function cloneOptimisticFields(fields) {
+    if (fields === undefined)
+        return Object.freeze({});
+    assertPlainReplicaRecord(fields, 'record fields');
+    return Object.freeze(Object.fromEntries(Object.entries(fields).map(([name, value]) => {
+        assertReplicaName(name, 'record field');
+        return [name, cloneJsonValue(value)];
+    })));
+}
+export function cloneOptimisticLinks(links) {
+    if (links === undefined)
+        return Object.freeze({});
+    assertPlainReplicaRecord(links, 'record links');
+    return Object.freeze(Object.fromEntries(Object.entries(links).map(([name, value]) => {
+        assertReplicaName(name, 'record link');
+        if (value === null)
+            return [name, null];
+        if (typeof value === 'string') {
+            assertReplicaName(value, 'record key');
+            return [name, value];
+        }
+        if (!Array.isArray(value)) {
+            throw new TypeError('record link must be a key, key array, or null');
+        }
+        const keys = value.map((key) => {
+            assertReplicaName(key, 'record key');
+            return key;
+        });
+        return [name, Object.freeze(keys)];
+    })));
+}
+export function assertPlainReplicaRecord(value, description) {
+    const prototype = Object.getPrototypeOf(value);
+    if (Array.isArray(value) ||
+        (prototype !== Object.prototype && prototype !== null)) {
+        throw new TypeError(`${description} must be a plain object`);
+    }
+}
+export function assertReplicaOptimisticLayerId(id) {
+    assertReplicaName(id, 'optimistic layer id');
+}
+export function assertReplicaName(value, description) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new TypeError(`${description} must be a non-empty string`);
+    }
+}
+export function assertReplicaOptimisticUpdateSynchronous(result) {
+    if (result !== null &&
+        (typeof result === 'object' || typeof result === 'function') &&
+        typeof result.then === 'function') {
+        void Promise.resolve(result).catch(() => undefined);
+        throw new TypeError('optimistic layer update must be synchronous');
+    }
+}

package/dist/replica/distributed-replica/types.d.ts

@@ -0,0 +1,147 @@
+import type { GqlError, GraphqlVariables } from '../../types.js';
+import type { CacheEngineSnapshot, CacheValue, OptimisticIndexWrite, OptimisticRecordWrite } from '../../internal/cache-engine.js';
+import type { DistributedDecimalString, DistributedLiveCursor, DistributedOpaqueString, DistributedTrustedPreset } from '../../protocol.js';
+import type { ReplicaTrustedPresetDescriptor } from '../commands.js';
+import type { ValidatedReplicaOperationBinding } from '../operation-binding.js';
+import type { ReplicaLiveState, ReplicaOperationArtifact, ReplicaValue } from '../types.js';
+export type QueryState = {
+    fetching: boolean;
+    errors: readonly GqlError[];
+    live: ReplicaLiveState;
+};
+export type LiveEntry = {
+    count: number;
+    unsubscribe: () => void;
+    active: boolean;
+    protocolGeneration: number;
+    operationGeneration?: number;
+};
+export type ProtocolGeneration = {
+    protocolVersion: 1;
+    cacheScope: DistributedOpaqueString;
+    schemaHash: string;
+};
+export type RenderedOperation = {
+    readonly artifact: ReplicaOperationArtifact<unknown, GraphqlVariables>;
+    readonly variables: GraphqlVariables;
+};
+export type SerializedOperationProtocolState = {
+    readonly operation: string;
+    readonly snapshotScope?: string;
+    readonly indexClocks: readonly (readonly [
+        string,
+        Readonly<{
+            scopeToken: string;
+            position: string;
+        }>
+    ])[];
+    readonly indexRevision?: string;
+    readonly indexKeys: readonly string[];
+    readonly pathRecords: readonly (readonly [string, string])[];
+    readonly cursors: readonly DistributedLiveCursor[];
+};
+export type SerializedOperationProtocolGroup = {
+    readonly key: string;
+    readonly query?: SerializedOperationProtocolState;
+    readonly live?: SerializedOperationProtocolState;
+    readonly active?: OperationProtocolSource;
+    readonly generation: number;
+};
+export type ReplicaDehydratedPayloadV1 = {
+    readonly cache: CacheEngineSnapshot;
+    readonly operations: readonly SerializedOperationProtocolGroup[];
+    readonly recordClocks: readonly (readonly [string, RecordProtocolClock])[];
+    readonly anonymousRecordClocks: readonly (readonly [
+        string,
+        AnonymousRecordProtocolClock
+    ])[];
+    readonly trustedPresets: readonly DistributedTrustedPreset[];
+    readonly nextIndexRevision: string;
+};
+export type ParsedReplicaHydration = {
+    readonly scope: ProtocolGeneration;
+    readonly cache: CacheEngineSnapshot;
+    readonly operationProtocols: Map<string, OperationProtocolGroup>;
+    readonly operationGenerations: Map<string, number>;
+    readonly recordClocks: Map<string, RecordProtocolClock>;
+    readonly recordKeysByScope: Map<DistributedOpaqueString, string>;
+    readonly anonymousRecordClocks: Map<DistributedOpaqueString, AnonymousRecordProtocolClock>;
+    readonly trustedPresets: readonly DistributedTrustedPreset[];
+    readonly nextIndexRevision: string;
+};
+export type RegisteredCommandAuthorityContract = {
+    readonly schemaHash: string;
+    readonly protocolHash: string;
+    readonly surfaceIdentity: string;
+    readonly trustedPresets: readonly ReplicaTrustedPresetDescriptor[];
+    readonly fingerprint: string;
+};
+export type ReplicaArtifactBinding = {
+    version: 1;
+    schemaHash: string;
+    surfaceIdentity?: string;
+    trustedPresets?: readonly ReplicaTrustedPresetDescriptor[];
+};
+export type ValidatedArtifactBinding = ValidatedReplicaOperationBinding;
+export type RecordProtocolClock = {
+    scopeToken: DistributedOpaqueString;
+    incarnation: DistributedDecimalString;
+    revision: DistributedDecimalString;
+    tombstone: boolean;
+};
+export type ProjectedRecordFence = {
+    readonly fields: Readonly<Record<string, ReplicaValue>>;
+    readonly clock: RecordProtocolClock;
+    readonly projectionGeneration: number;
+};
+export type AnonymousRecordProtocolClock = {
+    model: string;
+    clock: RecordProtocolClock;
+};
+export type IndexProtocolClock = {
+    scopeToken: DistributedOpaqueString;
+    position: DistributedDecimalString;
+};
+export type OperationProtocolState = {
+    operation: string;
+    snapshotScope?: DistributedOpaqueString;
+    indexClocks: Map<string, IndexProtocolClock>;
+    indexRevision?: string;
+    indexKeys: Set<string>;
+    pathRecords: Map<string, string>;
+    cursors: readonly DistributedLiveCursor[];
+};
+export type OperationProtocolSource = 'query' | 'live';
+export type OperationProtocolGroup = {
+    query?: OperationProtocolState;
+    live?: OperationProtocolState;
+    active?: OperationProtocolSource;
+};
+export type OptimisticReceiptState = {
+    causationId: DistributedOpaqueString;
+    expectations: ReadonlyMap<string, true>;
+    observed: Set<string>;
+};
+export type IndexDisposition = 'fresh' | 'equal' | 'higher' | 'lower' | 'incomparable';
+export type SharedIndexDisposition = {
+    readonly compared: boolean;
+    readonly disposition?: 'equal' | 'higher' | 'lower';
+    readonly indexRevision?: string;
+};
+export type CapturedReplicaOptimisticOperation = {
+    readonly kind: 'write-record';
+    readonly write: OptimisticRecordWrite;
+} | {
+    readonly kind: 'tombstone-record';
+    readonly key: string;
+} | {
+    readonly kind: 'write-index';
+    readonly write: OptimisticIndexWrite;
+} | {
+    readonly kind: 'delete-index';
+    readonly key: string;
+};
+export type CapturedReplicaOptimisticUpdate = {
+    readonly operations: readonly CapturedReplicaOptimisticOperation[];
+    readonly context: CacheValue;
+};

package/dist/replica/distributed-replica/types.js

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

package/dist/replica/distributed-replica/watch.d.ts

@@ -0,0 +1,19 @@
+import type { GraphqlVariables } from '../../types.js';
+import type { MaterializedReplicaResult } from '../materialize.js';
+import type { ReplicaOperationArtifact, ReplicaSnapshot, ReplicaWatch, WatchReplicaOptions } from '../types.js';
+import type { DistributedReplicaImpl } from './impl.js';
+export declare class ReplicaWatchState<TData, TVariables extends GraphqlVariables> implements ReplicaWatch<TData> {
+    #private;
+    readonly key: string;
+    readonly artifact: ReplicaOperationArtifact<TData, TVariables>;
+    readonly variables: TVariables;
+    readonly liveRequested: boolean;
+    materialized: MaterializedReplicaResult<TData>;
+    constructor(owner: DistributedReplicaImpl, artifact: ReplicaOperationArtifact<TData, TVariables>, variables: TVariables, options: WatchReplicaOptions);
+    get(): ReplicaSnapshot<TData>;
+    subscribe(listener: (snapshot: ReplicaSnapshot<TData>) => void): () => void;
+    refresh(): Promise<void>;
+    destroy(): void;
+    _cacheChanged(materialized: MaterializedReplicaResult<TData>): void;
+    _stateChanged(allowFetch: boolean): void;
+}

package/dist/replica/distributed-replica/watch.js

@@ -0,0 +1,95 @@
+import { canonicalizeOperationVariables } from '../identity.js';
+import { operationKey, snapshotEqual, snapshotFrom, deepEqual } from './helpers.js';
+export class ReplicaWatchState {
+    key;
+    artifact;
+    variables;
+    liveRequested;
+    materialized;
+    #owner;
+    #listeners = new Set();
+    #snapshot;
+    #identitySignature;
+    #destroyed = false;
+    #unregister;
+    constructor(owner, artifact, variables, options) {
+        this.#owner = owner;
+        this.artifact = artifact;
+        this.variables = canonicalizeOperationVariables(artifact, variables);
+        this.key = operationKey(artifact, this.variables);
+        this.liveRequested = options.live === true;
+        this.materialized = owner._materialize(artifact, this.variables);
+        this.#identitySignature = this.materialized.identitySignature;
+        this.#snapshot = snapshotFrom(this.materialized, owner._state(this.key));
+        this.#unregister = owner._register(this);
+    }
+    get() {
+        return this.#snapshot;
+    }
+    subscribe(listener) {
+        if (this.#destroyed)
+            throw new Error('replica watch is destroyed');
+        if (typeof listener !== 'function')
+            throw new TypeError('replica listener must be a function');
+        this.#listeners.add(listener);
+        try {
+            listener(this.#snapshot);
+        }
+        catch (error) {
+            this.#listeners.delete(listener);
+            this.#owner._reportObserverErrors([error]);
+        }
+        return () => this.#listeners.delete(listener);
+    }
+    refresh() {
+        if (this.#destroyed)
+            return Promise.reject(new Error('replica watch is destroyed'));
+        return this.#owner._fetch(this, true);
+    }
+    destroy() {
+        if (this.#destroyed)
+            return;
+        this.#destroyed = true;
+        this.#unregister();
+        this.#listeners.clear();
+    }
+    _cacheChanged(materialized) {
+        if (this.#destroyed)
+            return;
+        this.materialized = materialized;
+        this.#sync(true);
+    }
+    _stateChanged(allowFetch) {
+        if (this.#destroyed)
+            return;
+        this.#sync(allowFetch);
+    }
+    #sync(allowFetch) {
+        const state = this.#owner._state(this.key);
+        const nextRaw = snapshotFrom(this.materialized, state);
+        const keepData = this.#identitySignature === this.materialized.identitySignature &&
+            deepEqual(this.#snapshot.data, nextRaw.data);
+        this.#identitySignature = this.materialized.identitySignature;
+        const next = keepData
+            ? Object.freeze({
+                ...nextRaw,
+                data: this.#snapshot.data
+            })
+            : nextRaw;
+        if (!snapshotEqual(this.#snapshot, next)) {
+            this.#snapshot = next;
+            const errors = [];
+            for (const listener of this.#listeners) {
+                try {
+                    listener(next);
+                }
+                catch (error) {
+                    errors.push(error);
+                }
+            }
+            this.#owner._reportObserverErrors(errors);
+        }
+        if (allowFetch)
+            void this.#owner._fetch(this, false);
+    }
+}

package/dist/replica/distributed-replica.d.ts

@@ -0,0 +1,2 @@
+/** Public entry for createDistributedReplica; implementation lives in ./distributed-replica/. */
+export { createDistributedReplica } from './distributed-replica/index.js';

package/dist/replica/distributed-replica.js

@@ -0,0 +1,2 @@
+/** Public entry for createDistributedReplica; implementation lives in ./distributed-replica/. */
+export { createDistributedReplica } from './distributed-replica/index.js';

package/dist/replica/graphql-transport.d.ts

@@ -0,0 +1,24 @@
+import { type FetchLike } from '../request.js';
+import type { GqlAuth } from '../types.js';
+import { type WebSocketConstructor } from '../websocket.js';
+import type { ReplicaCommandTransport } from './command-runtime.js';
+import type { ReplicaTransport } from './types.js';
+export type ReplicaGraphqlTransportOptions = Readonly<{
+    /** GraphQL HTTP endpoint. Same-origin paths and absolute URLs are supported. */
+    getUrl: () => string;
+    /** One injected credential source shared by HTTP, command, and WebSocket work. */
+    getAuth: () => GqlAuth | Promise<GqlAuth>;
+    /** Request-scoped SvelteKit fetch on the server, or a test/browser override. */
+    fetch?: FetchLike;
+    /** Browser/test WebSocket constructor override. */
+    webSocket?: WebSocketConstructor;
+}>;
+/**
+ * One concrete GraphQL transport for generated replica reads, live operations,
+ * command dispatch, and command-status recovery.
+ *
+ * The transport is intentionally framework-neutral. Framework adapters inject
+ * their request/session lifecycle but never duplicate GraphQL protocol logic.
+ */
+export type ReplicaGraphqlTransport = ReplicaTransport & ReplicaCommandTransport;
+export declare function createReplicaGraphqlTransport(options: ReplicaGraphqlTransportOptions): ReplicaGraphqlTransport;

package/dist/replica/graphql-transport.js

@@ -0,0 +1,122 @@
+import { requestGraphql } from '../request.js';
+import { subscribe as subscribeGraphqlWs } from '../websocket.js';
+export function createReplicaGraphqlTransport(options) {
+    if (typeof options.getUrl !== 'function') {
+        throw new TypeError('replica GraphQL transport requires getUrl');
+    }
+    if (typeof options.getAuth !== 'function') {
+        throw new TypeError('replica GraphQL transport requires getAuth');
+    }
+    const execute = async (document, variables, extensions, signal) => {
+        const auth = await options.getAuth();
+        const result = await requestGraphql(options.getUrl(), document, auth, variables, {
+            ...(options.fetch === undefined ? {} : { fetch: options.fetch }),
+            extensions,
+            ...(signal === undefined ? {} : { signal })
+        });
+        return Object.freeze({
+            ...(result.data === undefined ? {} : { data: result.data }),
+            ...(result.errors === undefined ? {} : { errors: result.errors }),
+            ...(result.extensions === undefined
+                ? {}
+                : { extensions: result.extensions }),
+            status: result.status
+        });
+    };
+    return Object.freeze({
+        async fetch(request) {
+            const auth = await options.getAuth();
+            const result = await requestGraphql(options.getUrl(), request.document, auth, request.variables, {
+                ...(options.fetch === undefined ? {} : { fetch: options.fetch }),
+                ...(request.extensions === undefined
+                    ? {}
+                    : { extensions: request.extensions }),
+                ...(request.signal === undefined
+                    ? {}
+                    : { signal: request.signal })
+            });
+            return Object.freeze({
+                ...(result.data === undefined ? {} : { data: result.data }),
+                ...(result.errors === undefined ? {} : { errors: result.errors }),
+                ...(result.extensions === undefined
+                    ? {}
+                    : { extensions: result.extensions })
+            });
+        },
+        subscribe(request, observer) {
+            return subscribeReplicaOperation(options, request, observer);
+        },
+        dispatch(request) {
+            return execute(request.document, request.variables, request.extensions, request.signal);
+        },
+        status(request) {
+            return execute(request.document, request.variables, request.extensions, request.signal);
+        }
+    });
+}
+function subscribeReplicaOperation(options, request, observer) {
+    let unsubscribe = () => undefined;
+    let closed = false;
+    const close = () => {
+        if (closed)
+            return;
+        closed = true;
+        request.signal?.removeEventListener('abort', close);
+        unsubscribe();
+    };
+    const fail = (error) => {
+        if (closed)
+            return;
+        try {
+            observer.error(error);
+        }
+        finally {
+            close();
+        }
+    };
+    if (request.signal?.aborted) {
+        return close;
+    }
+    request.signal?.addEventListener('abort', close, { once: true });
+    void Promise.resolve()
+        .then(() => options.getAuth())
+        .then((auth) => {
+        if (closed || request.signal?.aborted)
+            return;
+        unsubscribe = subscribeGraphqlWs(request.document, auth, {
+            onNext: (result) => {
+                if (!closed)
+                    observer.next(result);
+            },
+            onError: fail,
+            onComplete: () => {
+                if (closed)
+                    return;
+                try {
+                    observer.complete();
+                }
+                finally {
+                    close();
+                }
+            }
+        }, {
+            httpUrl: options.getUrl(),
+            variables: request.variables,
+            ...(request.extensions === undefined
+                ? {}
+                : { extensions: request.extensions }),
+            ...(request.resume === undefined
+                ? {}
+                : { resume: request.resume }),
+            ...(options.webSocket === undefined
+                ? {}
+                : { webSocket: options.webSocket })
+        });
+        if (closed || request.signal?.aborted)
+            unsubscribe();
+    })
+        .catch((error) => {
+        fail(error);
+    });
+    return close;
+}