@hops-ops/distributed 0.0.0

package/dist/protocol.js

@@ -0,0 +1,558 @@
+/**
+ * Versioned framework metadata carried in GraphQL's top-level
+ * `extensions.distributed` response envelope.
+ *
+ * Domain result objects never contain these values. Hidden identities and
+ * positions remain opaque strings: the JavaScript client compares or returns
+ * them, but never parses them as numbers or reconstructs server scopes.
+ */
+/** The only Distributed GraphQL protocol version understood by this package. */
+export const DISTRIBUTED_PROTOCOL_VERSION = 1;
+/** Safe parse failure that reports structure, never hidden server values. */
+export class DistributedProtocolError extends Error {
+    code;
+    path;
+    constructor(code, path) {
+        super(code === 'DISTRIBUTED_PROTOCOL_VERSION_UNSUPPORTED'
+            ? 'Unsupported Distributed GraphQL protocol version'
+            : `Invalid Distributed GraphQL protocol envelope at ${path}`);
+        this.name = 'DistributedProtocolError';
+        this.code = code;
+        this.path = path;
+    }
+}
+const COMMAND_STATES = new Set([
+    'in_progress',
+    'accepted',
+    'accepted_pending_projection',
+    'projected',
+    'rejected',
+    'projection_failed',
+    'expired',
+    'unknown'
+]);
+const COMMAND_CONSISTENCIES = new Set([
+    'accepted',
+    'fact',
+    'projected'
+]);
+const MAX_PUBLIC_NAME_LENGTH = 512;
+const MAX_OPAQUE_STRING_LENGTH = 16_384;
+const MAX_EVIDENCE_ITEMS = 4_096;
+const MAX_LIVE_RESUME_CURSORS = 64;
+const MAX_PATH_SEGMENTS = 256;
+const MAX_TRUSTED_PRESETS = 4_096;
+const MAX_TRUSTED_PRESET_NAME_LENGTH = 128;
+const MAX_TRUSTED_PRESET_VALUE_DEPTH = 64;
+const MAX_UNSIGNED_64 = '18446744073709551615';
+const MAX_SAFE_INTEGER = 9_007_199_254_740_991;
+const CANONICAL_BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+/**
+ * Parse GraphQL's optional top-level `extensions` object.
+ *
+ * Non-Distributed extension keys are preserved. When `distributed` is present,
+ * its required version/scope/schema fields and known receipt/evidence fields are
+ * validated. A malformed or incompatible envelope throws
+ * {@link DistributedProtocolError}; transports convert that into a fail-closed
+ * GraphQL result/error rather than exposing the accompanying data as trusted.
+ */
+export function parseGraphqlResponseExtensions(value) {
+    if (value === undefined)
+        return undefined;
+    const extensions = record(value, 'extensions');
+    if (extensions.distributed === undefined) {
+        return Object.freeze({ ...extensions });
+    }
+    return Object.freeze({
+        ...extensions,
+        distributed: parseDistributedProtocolEnvelope(extensions.distributed)
+    });
+}
+/** Parse one `extensions.distributed` value independently of a transport. */
+export function parseDistributedProtocolEnvelope(value) {
+    const envelope = record(value, 'extensions.distributed');
+    if (envelope.protocolVersion !== DISTRIBUTED_PROTOCOL_VERSION) {
+        if (typeof envelope.protocolVersion === 'number' &&
+            Number.isInteger(envelope.protocolVersion)) {
+            throw new DistributedProtocolError('DISTRIBUTED_PROTOCOL_VERSION_UNSUPPORTED', 'extensions.distributed.protocolVersion');
+        }
+        invalid('extensions.distributed.protocolVersion');
+    }
+    const schemaHash = publicString(envelope.schemaHash, 'extensions.distributed.schemaHash');
+    const cacheScope = opaqueString(envelope.cacheScope, 'extensions.distributed.cacheScope');
+    const operation = envelope.operation === undefined
+        ? undefined
+        : publicString(envelope.operation, 'extensions.distributed.operation');
+    const command = envelope.command === undefined
+        ? undefined
+        : parseCommand(envelope.command);
+    const snapshot = envelope.snapshot === undefined
+        ? undefined
+        : parseSnapshot(envelope.snapshot);
+    const live = envelope.live === undefined
+        ? undefined
+        : parseLive(envelope.live);
+    validateLiveSnapshot(snapshot, live);
+    const trustedPresets = parseDistributedTrustedPresetInventory(envelope.trustedPresets);
+    return Object.freeze({
+        ...envelope,
+        protocolVersion: DISTRIBUTED_PROTOCOL_VERSION,
+        schemaHash,
+        cacheScope,
+        ...(operation === undefined ? {} : { operation }),
+        ...(command === undefined ? {} : { command }),
+        ...(snapshot === undefined ? {} : { snapshot }),
+        ...(live === undefined ? {} : { live }),
+        trustedPresets
+    });
+}
+/**
+ * Parse and deeply freeze one scope-wide trusted-preset value inventory.
+ *
+ * This is exported for the framework-neutral replica's internal command seam.
+ * Applications receive the same values through
+ * {@link parseDistributedProtocolEnvelope}; they must never supply this
+ * inventory as command authority.
+ *
+ * @internal
+ */
+export function parseDistributedTrustedPresetInventory(value, path = 'extensions.distributed.trustedPresets') {
+    if (value === undefined)
+        return Object.freeze([]);
+    if (!Array.isArray(value) || value.length > MAX_TRUSTED_PRESETS) {
+        invalid(path);
+    }
+    const names = new Set();
+    const presets = value.map((candidate, index) => {
+        const itemPath = `${path}[${index}]`;
+        const item = record(candidate, itemPath);
+        const name = trustedPresetName(item.name, `${itemPath}.name`);
+        if (names.has(name))
+            invalid(`${itemPath}.name`);
+        names.add(name);
+        const codec = trustedPresetCodec(item.codec, `${itemPath}.codec`);
+        return Object.freeze({
+            name,
+            codec,
+            value: parseTrustedPresetValue(item.value, codec, `${itemPath}.value`)
+        });
+    });
+    return Object.freeze(presets);
+}
+/**
+ * Build the private request extension for a generated live resume.
+ *
+ * The server remains authoritative and verifies every token. This client-side
+ * check only prevents malformed, duplicate, or unbounded state from leaving
+ * the replica.
+ *
+ * @internal
+ */
+export function distributedLiveResumeExtensions(value) {
+    if (!Array.isArray(value) ||
+        value.length === 0 ||
+        value.length > MAX_LIVE_RESUME_CURSORS) {
+        invalid('request.extensions.distributed.resume.cursors');
+    }
+    const cursors = Object.freeze(value.map((cursor, index) => parseLiveCursor(cursor, `request.extensions.distributed.resume.cursors[${index}]`)));
+    assertUnique(cursors.map((cursor) => cursor.projection), 'request.extensions.distributed.resume.cursors');
+    return Object.freeze({
+        distributed: Object.freeze({
+            resume: Object.freeze({ cursors })
+        })
+    });
+}
+function parseCommand(value) {
+    const command = record(value, 'extensions.distributed.command');
+    const state = enumString(command.state, COMMAND_STATES, 'extensions.distributed.command.state');
+    const consistency = enumString(command.consistency, COMMAND_CONSISTENCIES, 'extensions.distributed.command.consistency');
+    if (!Array.isArray(command.expects)) {
+        invalid('extensions.distributed.command.expects');
+    }
+    if (command.expects.length > MAX_EVIDENCE_ITEMS) {
+        invalid('extensions.distributed.command.expects');
+    }
+    const expects = command.expects.map((expectation, index) => {
+        const path = `extensions.distributed.command.expects[${index}]`;
+        const item = record(expectation, path);
+        return Object.freeze({
+            ...item,
+            projection: publicString(item.projection, `${path}.projection`),
+            model: publicString(item.model, `${path}.model`),
+            scopeToken: opaqueString(item.scopeToken, `${path}.scopeToken`)
+        });
+    });
+    const observations = parseOptionalEvidenceArray(command.observations, 'extensions.distributed.command.observations', parseProjectionObservation);
+    const records = parseOptionalEvidenceArray(command.records, 'extensions.distributed.command.records', parseRecordRevision);
+    const commandId = opaqueString(command.commandId, 'extensions.distributed.command.commandId');
+    const causationId = opaqueString(command.causationId, 'extensions.distributed.command.causationId');
+    const expectationKeys = new Set(expects.map(projectionExpectationKey));
+    const seenObservations = new Set();
+    for (const observation of observations) {
+        const key = projectionObservationKey(observation);
+        if (observation.causationId !== causationId ||
+            !expectationKeys.has(projectionExpectationKey(observation)) ||
+            seenObservations.has(key)) {
+            invalid('extensions.distributed.command.observations');
+        }
+        seenObservations.add(key);
+    }
+    return Object.freeze({
+        ...command,
+        commandId,
+        causationId,
+        state,
+        consistency,
+        expects: Object.freeze(expects),
+        observations,
+        records
+    });
+}
+function parseSnapshot(value) {
+    const path = 'extensions.distributed.snapshot';
+    const snapshot = record(value, path);
+    if (typeof snapshot.recordsComplete !== 'boolean') {
+        invalid(`${path}.recordsComplete`);
+    }
+    if (typeof snapshot.indexesComparable !== 'boolean') {
+        invalid(`${path}.indexesComparable`);
+    }
+    const records = parseRequiredEvidenceArray(snapshot.records, `${path}.records`, parseRecordRevision);
+    const indexes = parseRequiredEvidenceArray(snapshot.indexes, `${path}.indexes`, parseIndexRevision);
+    const observations = parseRequiredEvidenceArray(snapshot.observations, `${path}.observations`, parseProjectionObservation);
+    assertUnique(indexes.map((index) => index.projection), `${path}.indexes`);
+    if (indexes.filter((index) => index.resume !== undefined).length >
+        MAX_LIVE_RESUME_CURSORS) {
+        invalid(`${path}.indexes`);
+    }
+    if (!snapshot.indexesComparable &&
+        (indexes.length > 0 || observations.length > 0)) {
+        invalid(`${path}.indexesComparable`);
+    }
+    return Object.freeze({
+        ...snapshot,
+        scopeToken: opaqueString(snapshot.scopeToken, `${path}.scopeToken`),
+        recordsComplete: snapshot.recordsComplete,
+        indexesComparable: snapshot.indexesComparable,
+        records,
+        indexes,
+        observations
+    });
+}
+function parseLive(value) {
+    const path = 'extensions.distributed.live';
+    const live = record(value, path);
+    if (typeof live.supported !== 'boolean')
+        invalid(`${path}.supported`);
+    if (typeof live.reset !== 'boolean')
+        invalid(`${path}.reset`);
+    if (!Array.isArray(live.cursors) ||
+        live.cursors.length > MAX_LIVE_RESUME_CURSORS) {
+        invalid(`${path}.cursors`);
+    }
+    const cursors = parseRequiredEvidenceArray(live.cursors, `${path}.cursors`, parseLiveCursor);
+    assertUnique(cursors.map((cursor) => cursor.projection), `${path}.cursors`);
+    if (!live.supported && (!live.reset || cursors.length !== 0)) {
+        invalid(path);
+    }
+    return Object.freeze({
+        ...live,
+        supported: live.supported,
+        reset: live.reset,
+        cursors
+    });
+}
+function validateLiveSnapshot(snapshot, live) {
+    if (live === undefined)
+        return;
+    if (snapshot === undefined)
+        invalid('extensions.distributed.snapshot');
+    if (!live.supported)
+        return;
+    if (!snapshot.indexesComparable) {
+        invalid('extensions.distributed.snapshot.indexesComparable');
+    }
+    if (live.cursors.length === 0 ||
+        snapshot.indexes.length !== live.cursors.length) {
+        invalid('extensions.distributed.live.cursors');
+    }
+    const indexes = new Map(snapshot.indexes.map((index) => [index.projection, index]));
+    for (const cursor of live.cursors) {
+        const index = indexes.get(cursor.projection);
+        if (index === undefined ||
+            index.position !== cursor.position ||
+            index.resume === undefined ||
+            index.resume.token !== cursor.token) {
+            invalid('extensions.distributed.live.cursors');
+        }
+    }
+}
+function parseRecordRevision(value, path) {
+    const item = record(value, path);
+    let responsePath;
+    if (item.path !== undefined) {
+        if (!Array.isArray(item.path) ||
+            item.path.length === 0 ||
+            item.path.length > MAX_PATH_SEGMENTS) {
+            invalid(`${path}.path`);
+        }
+        responsePath = Object.freeze(item.path.map((segment, index) => publicString(segment, `${path}.path[${index}]`)));
+    }
+    if (typeof item.tombstone !== 'boolean')
+        invalid(`${path}.tombstone`);
+    return Object.freeze({
+        ...item,
+        ...(responsePath === undefined ? {} : { path: responsePath }),
+        model: publicString(item.model, `${path}.model`),
+        scopeToken: opaqueString(item.scopeToken, `${path}.scopeToken`),
+        incarnation: canonicalDecimal(item.incarnation, `${path}.incarnation`),
+        revision: canonicalDecimal(item.revision, `${path}.revision`),
+        tombstone: item.tombstone
+    });
+}
+function parseProjectionObservation(value, path) {
+    const item = record(value, path);
+    return Object.freeze({
+        ...item,
+        causationId: opaqueString(item.causationId, `${path}.causationId`),
+        projection: publicString(item.projection, `${path}.projection`),
+        model: publicString(item.model, `${path}.model`),
+        scopeToken: opaqueString(item.scopeToken, `${path}.scopeToken`)
+    });
+}
+function parseIndexRevision(value, path) {
+    const item = record(value, path);
+    const projection = publicString(item.projection, `${path}.projection`);
+    const position = canonicalDecimal(item.position, `${path}.position`);
+    const resume = item.resume === undefined
+        ? undefined
+        : parseLiveCursor(item.resume, `${path}.resume`);
+    if (resume !== undefined &&
+        (resume.projection !== projection || resume.position !== position)) {
+        invalid(`${path}.resume`);
+    }
+    return Object.freeze({
+        ...item,
+        projection,
+        scopeToken: opaqueString(item.scopeToken, `${path}.scopeToken`),
+        position,
+        ...(resume === undefined ? {} : { resume })
+    });
+}
+function parseLiveCursor(value, path) {
+    const item = record(value, path);
+    return Object.freeze({
+        ...item,
+        projection: publicString(item.projection, `${path}.projection`),
+        position: canonicalDecimal(item.position, `${path}.position`),
+        token: opaqueString(item.token, `${path}.token`)
+    });
+}
+function parseRequiredEvidenceArray(value, path, parse) {
+    if (!Array.isArray(value) || value.length > MAX_EVIDENCE_ITEMS)
+        invalid(path);
+    return Object.freeze(value.map((item, index) => parse(item, `${path}[${index}]`)));
+}
+function parseOptionalEvidenceArray(value, path, parse) {
+    return value === undefined
+        ? Object.freeze([])
+        : parseRequiredEvidenceArray(value, path, parse);
+}
+function projectionExpectationKey(value) {
+    return JSON.stringify([value.projection, value.model, value.scopeToken]);
+}
+function projectionObservationKey(value) {
+    return JSON.stringify([
+        value.causationId,
+        value.projection,
+        value.model,
+        value.scopeToken
+    ]);
+}
+function assertUnique(values, path) {
+    if (new Set(values).size !== values.length)
+        invalid(path);
+}
+function record(value, path) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        invalid(path);
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        invalid(path);
+    return value;
+}
+function publicString(value, path) {
+    if (typeof value !== 'string' ||
+        value.length === 0 ||
+        value.length > MAX_PUBLIC_NAME_LENGTH) {
+        invalid(path);
+    }
+    return value;
+}
+function trustedPresetName(value, path) {
+    if (typeof value !== 'string' ||
+        value.length === 0 ||
+        value.length > MAX_TRUSTED_PRESET_NAME_LENGTH ||
+        value.trim() !== value ||
+        /[\u0000-\u001f\u007f-\u009f]/.test(value)) {
+        invalid(path);
+    }
+    return value;
+}
+/** @internal */
+export function isDistributedTrustedPresetCodec(value) {
+    return (value === 'string' ||
+        value === 'string_unvalidated_timestamp' ||
+        value === 'base64' ||
+        value === 'boolean' ||
+        value === 'int32' ||
+        value === 'float64' ||
+        value === 'json_number_precision_limited' ||
+        value === 'json');
+}
+function trustedPresetCodec(value, path) {
+    if (!isDistributedTrustedPresetCodec(value))
+        invalid(path);
+    return value;
+}
+function parseTrustedPresetValue(value, codec, path) {
+    switch (codec) {
+        case 'string':
+        case 'string_unvalidated_timestamp':
+            if (typeof value !== 'string')
+                invalid(path);
+            return value;
+        case 'base64':
+            if (typeof value !== 'string' || !CANONICAL_BASE64.test(value)) {
+                invalid(path);
+            }
+            return value;
+        case 'boolean':
+            if (typeof value !== 'boolean')
+                invalid(path);
+            return value;
+        case 'int32':
+            if (typeof value !== 'number' ||
+                !Number.isInteger(value) ||
+                Object.is(value, -0) ||
+                value < -2_147_483_648 ||
+                value > 2_147_483_647) {
+                invalid(path);
+            }
+            return value;
+        case 'json_number_precision_limited':
+            if (typeof value !== 'number' ||
+                !Number.isInteger(value) ||
+                Object.is(value, -0) ||
+                value < -MAX_SAFE_INTEGER ||
+                value > MAX_SAFE_INTEGER) {
+                invalid(path);
+            }
+            return value;
+        case 'float64':
+            if (typeof value !== 'number' || !Number.isFinite(value)) {
+                invalid(path);
+            }
+            return Object.is(value, -0) ? 0 : value;
+        case 'json':
+            return cloneProtocolValue(value, path);
+    }
+}
+function cloneProtocolValue(value, path, active = new Set(), depth = 0) {
+    if (depth > MAX_TRUSTED_PRESET_VALUE_DEPTH)
+        invalid(path);
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            invalid(path);
+        return Object.is(value, -0) ? 0 : value;
+    }
+    if (typeof value !== 'object' || active.has(value))
+        invalid(path);
+    active.add(value);
+    if (Array.isArray(value)) {
+        if (Object.getPrototypeOf(value) !== Array.prototype)
+            invalid(path);
+        const ownKeys = Reflect.ownKeys(value);
+        if (ownKeys.some((key) => key !== 'length' &&
+            (typeof key !== 'string' ||
+                !/^(0|[1-9][0-9]*)$/.test(key) ||
+                Number(key) >= value.length))) {
+            invalid(path);
+        }
+        const result = [];
+        for (let index = 0; index < value.length; index += 1) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+            if (descriptor === undefined ||
+                !('value' in descriptor) ||
+                descriptor.value === undefined) {
+                invalid(`${path}[${index}]`);
+            }
+            result.push(cloneProtocolValue(descriptor.value, `${path}[${index}]`, active, depth + 1));
+        }
+        active.delete(value);
+        return Object.freeze(result);
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        invalid(path);
+    const keys = Reflect.ownKeys(value);
+    if (keys.some((key) => typeof key !== 'string'))
+        invalid(path);
+    const result = {};
+    for (const key of keys.sort()) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor === undefined ||
+            !('value' in descriptor) ||
+            descriptor.value === undefined) {
+            invalid(`${path}.${key}`);
+        }
+        Object.defineProperty(result, key, {
+            value: cloneProtocolValue(descriptor.value, `${path}.${key}`, active, depth + 1),
+            enumerable: true,
+            configurable: false,
+            writable: false
+        });
+    }
+    active.delete(value);
+    return Object.freeze(result);
+}
+function opaqueString(value, path) {
+    if (typeof value !== 'string' ||
+        value.length === 0 ||
+        value.length > MAX_OPAQUE_STRING_LENGTH) {
+        invalid(path);
+    }
+    return value;
+}
+function canonicalDecimal(value, path) {
+    if (typeof value !== 'string' ||
+        !/^(0|[1-9][0-9]*)$/.test(value) ||
+        value.length > MAX_UNSIGNED_64.length ||
+        (value.length === MAX_UNSIGNED_64.length && value > MAX_UNSIGNED_64)) {
+        invalid(path);
+    }
+    return value;
+}
+/**
+ * Compare two already-validated protocol decimals without converting either
+ * through JavaScript's numeric types.
+ */
+export function compareDistributedDecimal(left, right) {
+    if (left.length !== right.length)
+        return left.length < right.length ? -1 : 1;
+    return left === right ? 0 : left < right ? -1 : 1;
+}
+function enumString(value, values, path) {
+    if (typeof value !== 'string' || !values.has(value))
+        invalid(path);
+    return value;
+}
+function invalid(path) {
+    throw new DistributedProtocolError('DISTRIBUTED_PROTOCOL_INVALID', path);
+}

package/dist/react/context.d.ts

@@ -0,0 +1,20 @@
+import { type ReactElement, type ReactNode } from 'react';
+import type { DistributedReplica } from '../replica/types.js';
+export type DistributedProviderProps = {
+    /**
+     * One framework-neutral replica for this browser authorization lifecycle, or
+     * one fresh replica for this server-render request.
+     */
+    readonly replica: DistributedReplica;
+    readonly children?: ReactNode;
+};
+/**
+ * Makes an existing framework-neutral replica available to React.
+ *
+ * The provider deliberately does not create, hydrate, authorize, or retain a
+ * replica. Those lifecycles stay in the shared core and application
+ * composition, which keeps SSR request isolation explicit.
+ */
+export declare function DistributedProvider({ replica, children }: DistributedProviderProps): ReactElement;
+/** Read the exact replica supplied by the nearest DistributedProvider. */
+export declare function useDistributedReplica(): DistributedReplica;

package/dist/react/context.js

@@ -0,0 +1,24 @@
+'use client';
+import { createContext, createElement, useContext } from 'react';
+const DistributedReplicaContext = createContext(undefined);
+/**
+ * Makes an existing framework-neutral replica available to React.
+ *
+ * The provider deliberately does not create, hydrate, authorize, or retain a
+ * replica. Those lifecycles stay in the shared core and application
+ * composition, which keeps SSR request isolation explicit.
+ */
+export function DistributedProvider({ replica, children }) {
+    if (replica === undefined || replica === null) {
+        throw new TypeError('DistributedProvider requires a replica');
+    }
+    return createElement(DistributedReplicaContext.Provider, { value: replica }, children);
+}
+/** Read the exact replica supplied by the nearest DistributedProvider. */
+export function useDistributedReplica() {
+    const replica = useContext(DistributedReplicaContext);
+    if (replica === undefined) {
+        throw new Error('useDistributedReplica must be used inside a DistributedProvider');
+    }
+    return replica;
+}

package/dist/react/index.d.ts

@@ -0,0 +1,2 @@
+export { DistributedProvider, useDistributedReplica, type DistributedProviderProps } from './context.js';
+export { useDistributedQuery, type DistributedQueryResult } from './query.js';

package/dist/react/index.js

@@ -0,0 +1,3 @@
+'use client';
+export { DistributedProvider, useDistributedReplica } from './context.js';
+export { useDistributedQuery } from './query.js';

package/dist/react/query.d.ts

@@ -0,0 +1,20 @@
+import type { GraphqlVariables } from '../types.js';
+import type { ReplicaOperationArtifact, ReplicaSnapshot, WatchReplicaOptions } from '../replica/types.js';
+type UseDistributedQueryArguments<TVariables extends GraphqlVariables> = keyof TVariables extends never ? readonly [
+    variables?: TVariables,
+    options?: WatchReplicaOptions
+] : readonly [
+    variables: TVariables,
+    options?: WatchReplicaOptions
+];
+export type DistributedQueryResult<TData> = ReplicaSnapshot<TData> & {
+    /** Force the shared cache-and-live coordinator to revalidate this operation. */
+    readonly refresh: () => Promise<void>;
+};
+/**
+ * Bind a generated operation artifact to React without introducing a React
+ * cache. All reads, fetches, live updates, optimism, and authorization fences
+ * continue through the supplied DistributedReplica.
+ */
+export declare function useDistributedQuery<TData, TVariables extends GraphqlVariables>(artifact: ReplicaOperationArtifact<TData, TVariables>, ...args: UseDistributedQueryArguments<TVariables>): DistributedQueryResult<TData>;
+export {};