@hops-ops/distributed 0.0.0

package/dist/replica/diagnostics/event-log.js

@@ -0,0 +1,463 @@
+import { DIAGNOSTICS_BUNDLE_MARKER } from './types.js';
+import { reportUnhandledError } from '../../lib/report.js';
+import { inspectReplicaCommandArtifact, inspectReplicaOperationArtifact } from './inspect.js';
+const reportUnhandledObserverError = reportUnhandledError;
+const DEFAULT_MAX_EVENTS = 200;
+const MAX_EVENTS = 10_000;
+const MAX_VALUE_DEPTH = 64;
+const MAX_REASON_LENGTH = 160;
+const developmentCapabilities = new WeakSet();
+export function createReplicaDevelopmentCapability() {
+    const capability = Object.freeze({ version: 1 });
+    developmentCapabilities.add(capability);
+    return capability;
+}
+/** Framework-neutral diagnostics store shared by every framework adapter. */
+export function createReplicaDiagnostics(options = {}) {
+    return new ReplicaDiagnosticsImpl(options);
+}
+class ReplicaDiagnosticsImpl {
+    includeStructuralIdentities;
+    #maxEvents;
+    #now;
+    #reportObserverError;
+    #fieldValues;
+    #reasons;
+    #listeners = new Set();
+    #pseudonyms = new Map();
+    #operations = new Map();
+    #commands = new Map();
+    #scope = Object.freeze({
+        generation: 0,
+        established: false
+    });
+    #records = Object.freeze([]);
+    #indexes = Object.freeze([]);
+    #layers = Object.freeze([]);
+    #receipts = Object.freeze([]);
+    #events = [];
+    #sequence = 0;
+    #snapshotCache;
+    constructor(options) {
+        this.#maxEvents = boundedEventLimit(options.maxEvents);
+        this.#now = options.now ?? Date.now;
+        this.#reportObserverError =
+            options.onObserverError ?? reportUnhandledObserverError;
+        this.includeStructuralIdentities = validCapability(options.development);
+        if (options.fieldValues !== undefined) {
+            if (!validCapability(options.fieldValues.capability)) {
+                throw new TypeError('diagnostic field values require a development capability');
+            }
+            if (typeof options.fieldValues.allow !== 'function' ||
+                typeof options.fieldValues.redact !== 'function') {
+                throw new TypeError('diagnostic field values require explicit allow and redact functions');
+            }
+            this.#fieldValues = options.fieldValues;
+        }
+        if (options.reasons !== undefined) {
+            if (!validCapability(options.reasons.capability)) {
+                throw new TypeError('diagnostic reasons require a development capability');
+            }
+            if (typeof options.reasons.redact !== 'function') {
+                throw new TypeError('diagnostic reasons require an explicit redact function');
+            }
+            this.#reasons = options.reasons;
+        }
+    }
+    redactRecordValue(context, value) {
+        const policy = this.#fieldValues;
+        if (policy === undefined || !policy.allow(context))
+            return undefined;
+        const redacted = policy.redact(value, context);
+        return redacted === undefined
+            ? undefined
+            : cloneDiagnosticValue(redacted, 'diagnostic field value');
+    }
+    update(state) {
+        validateScope(state.scope);
+        if (state.scope.generation !== this.#scope.generation) {
+            this.#clearScopedState();
+        }
+        this.#scope = freezeScope(state.scope);
+        this.#records = Object.freeze(state.records
+            .map((record) => this.#record(record))
+            .sort((left, right) => left.key.localeCompare(right.key)));
+        this.#indexes = Object.freeze(state.indexes
+            .map((index) => this.#index(index))
+            .sort((left, right) => left.key.localeCompare(right.key)));
+        this.#layers = Object.freeze(state.layers
+            .map((layer) => this.#layer(layer))
+            .sort((left, right) => left.sequence - right.sequence));
+        this.#receipts = Object.freeze(state.receipts
+            .map((receipt) => this.#receipt(receipt))
+            .sort((left, right) => left.commandId.localeCompare(right.commandId)));
+        this.#snapshotCache = undefined;
+        this.#notify();
+    }
+    event(input) {
+        const at = this.#now();
+        if (!Number.isFinite(at)) {
+            throw new TypeError('diagnostic clock must return a finite number');
+        }
+        const event = this.#event(input, ++this.#sequence, at);
+        this.#events.push(event);
+        if (this.#events.length > this.#maxEvents) {
+            this.#events.splice(0, this.#events.length - this.#maxEvents);
+        }
+        this.#snapshotCache = undefined;
+        this.#notify();
+    }
+    operation(artifact) {
+        const inspection = inspectReplicaOperationArtifact(artifact);
+        this.#operations.set(inspection.id, inspection);
+        this.#snapshotCache = undefined;
+        this.#notify();
+    }
+    command(artifact) {
+        const inspection = inspectReplicaCommandArtifact(artifact);
+        this.#commands.set(inspection.name, inspection);
+        this.#snapshotCache = undefined;
+        this.#notify();
+    }
+    inspectOperation(artifact) {
+        const inspection = inspectReplicaOperationArtifact(artifact);
+        this.#operations.set(inspection.id, inspection);
+        this.#snapshotCache = undefined;
+        this.#notify();
+        return inspection;
+    }
+    inspectCommand(artifact) {
+        const inspection = inspectReplicaCommandArtifact(artifact);
+        this.#commands.set(inspection.name, inspection);
+        this.#snapshotCache = undefined;
+        this.#notify();
+        return inspection;
+    }
+    snapshot = () => {
+        const cached = this.#snapshotCache;
+        if (cached !== undefined)
+            return cached;
+        const snapshot = Object.freeze({
+            version: 1,
+            marker: DIAGNOSTICS_BUNDLE_MARKER,
+            mode: this.includeStructuralIdentities ? 'development' : 'redacted',
+            sequence: this.#sequence,
+            scope: this.#scope,
+            records: this.#records,
+            indexes: this.#indexes,
+            layers: this.#layers,
+            receipts: this.#receipts,
+            artifacts: Object.freeze({
+                operations: Object.freeze([...this.#operations.values()].sort((left, right) => left.id.localeCompare(right.id))),
+                commands: Object.freeze([...this.#commands.values()].sort((left, right) => left.name.localeCompare(right.name)))
+            }),
+            events: Object.freeze([...this.#events])
+        });
+        this.#snapshotCache = snapshot;
+        return snapshot;
+    };
+    getSnapshot = () => this.snapshot();
+    subscribe = (listener) => {
+        if (typeof listener !== 'function') {
+            throw new TypeError('diagnostic listener must be a function');
+        }
+        this.#listeners.add(listener);
+        try {
+            listener(this.snapshot());
+        }
+        catch (error) {
+            this.#listeners.delete(listener);
+            this.#report([error]);
+        }
+        return () => this.#listeners.delete(listener);
+    };
+    clear() {
+        this.#scope = Object.freeze({ generation: 0, established: false });
+        this.#clearScopedState();
+        this.#sequence = 0;
+        this.#snapshotCache = undefined;
+        this.#notify();
+    }
+    #clearScopedState() {
+        this.#records = Object.freeze([]);
+        this.#indexes = Object.freeze([]);
+        this.#layers = Object.freeze([]);
+        this.#receipts = Object.freeze([]);
+        this.#events = [];
+        this.#operations.clear();
+        this.#commands.clear();
+        this.#pseudonyms.clear();
+        this.#snapshotCache = undefined;
+    }
+    #record(input) {
+        const values = this.#fieldValues === undefined || input.values === undefined
+            ? undefined
+            : freezeValueRecord(input.values, 'diagnostic record values');
+        return Object.freeze({
+            key: this.#identifier('record', input.key),
+            ...(input.model === undefined ? {} : { model: input.model }),
+            revision: input.revision,
+            incarnation: input.incarnation,
+            tombstone: input.tombstone,
+            ...(input.tombstoneRevision === undefined
+                ? {}
+                : { tombstoneRevision: input.tombstoneRevision }),
+            presentFields: Object.freeze([...input.presentFields].sort()),
+            presentLinks: Object.freeze([...input.presentLinks].sort()),
+            ...(values === undefined ? {} : { values })
+        });
+    }
+    #index(input) {
+        const rawArguments = input.arguments ?? Object.freeze({});
+        const argumentsValue = this.includeStructuralIdentities && Object.keys(rawArguments).length > 0
+            ? freezeValueRecord(rawArguments, 'diagnostic index arguments')
+            : undefined;
+        const staleReason = input.staleReason === undefined
+            ? undefined
+            : this.#reason(input.staleReason, Object.freeze({
+                kind: 'index-stale',
+                indexKey: input.key
+            }), structuralStaleReason(input.staleReason));
+        return Object.freeze({
+            key: this.#identifier('index', input.key),
+            revision: input.revision,
+            ...(input.staleRevision === undefined
+                ? {}
+                : { staleRevision: input.staleRevision }),
+            records: Object.freeze(input.records.map((key) => this.#identifier('record', key))),
+            complete: input.complete,
+            deleted: input.deleted,
+            ...(input.field === undefined ? {} : { field: input.field }),
+            ...(input.parent === undefined
+                ? {}
+                : { parent: this.#identifier('record', input.parent) }),
+            argumentNames: Object.freeze([...(input.argumentNames ?? Object.keys(rawArguments))].sort()),
+            ...(argumentsValue === undefined ? {} : { arguments: argumentsValue }),
+            ...(input.coverage === undefined
+                ? {}
+                : { coverage: freezeCoverage(input.coverage) }),
+            dependencies: Object.freeze([...(input.dependencies ?? [])].sort()),
+            ...(staleReason === undefined ? {} : { staleReason }),
+            nullValue: input.nullValue === true
+        });
+    }
+    #layer(input) {
+        return Object.freeze({
+            id: this.#identifier('transaction', input.id),
+            sequence: input.sequence,
+            state: input.state,
+            recordChanges: input.recordChanges,
+            indexChanges: input.indexChanges,
+            semanticChanges: input.semanticChanges
+        });
+    }
+    #receipt(input) {
+        return Object.freeze({
+            commandId: this.#identifier('transaction', input.commandId),
+            state: input.state,
+            ...(input.consistency === undefined
+                ? {}
+                : { consistency: input.consistency }),
+            expectations: Object.freeze(input.expectations
+                .map((expectation) => Object.freeze({
+                projection: expectation.projection,
+                model: expectation.model,
+                observed: expectation.observed
+            }))
+                .sort((left, right) => `${left.projection}\0${left.model}`.localeCompare(`${right.projection}\0${right.model}`)))
+        });
+    }
+    #event(input, sequence, at) {
+        if (input.kind === 'layer') {
+            const reason = input.reason === undefined
+                ? undefined
+                : this.#reason(input.reason, Object.freeze({
+                    kind: 'layer',
+                    layerId: input.layer,
+                    action: input.action
+                }), structuralLayerReason(input.reason));
+            return Object.freeze({
+                ...input,
+                layer: this.#identifier('transaction', input.layer),
+                ...(reason === undefined ? {} : { reason }),
+                sequence,
+                at
+            });
+        }
+        if (input.kind === 'receipt') {
+            return Object.freeze({
+                ...input,
+                command: this.#identifier('transaction', input.command),
+                sequence,
+                at
+            });
+        }
+        if (input.kind === 'index-decision') {
+            const reason = input.reason === undefined
+                ? undefined
+                : this.#reason(input.reason, Object.freeze({
+                    kind: 'index-stale',
+                    indexKey: input.index
+                }), structuralStaleReason(input.reason));
+            return Object.freeze({
+                ...input,
+                index: this.#identifier('index', input.index),
+                ...(reason === undefined ? {} : { reason }),
+                sequence,
+                at
+            });
+        }
+        return Object.freeze({ ...input, sequence, at });
+    }
+    #reason(value, context, fallback) {
+        const redacted = this.#reasons?.redact(value, context);
+        return redacted === undefined
+            ? fallback
+            : boundedDiagnosticReason(redacted, fallback);
+    }
+    #identifier(kind, value) {
+        if (this.includeStructuralIdentities)
+            return value;
+        let values = this.#pseudonyms.get(kind);
+        if (values === undefined) {
+            values = new Map();
+            this.#pseudonyms.set(kind, values);
+        }
+        let identifier = values.get(value);
+        if (identifier === undefined) {
+            identifier = `${kind}#${values.size + 1}`;
+            values.set(value, identifier);
+        }
+        return identifier;
+    }
+    #notify() {
+        if (this.#listeners.size === 0)
+            return;
+        const snapshot = this.snapshot();
+        const errors = [];
+        for (const listener of this.#listeners) {
+            try {
+                listener(snapshot);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        this.#report(errors);
+    }
+    #report(errors) {
+        if (errors.length === 0)
+            return;
+        try {
+            this.#reportObserverError(new AggregateError(errors, 'replica diagnostic listener failed'));
+        }
+        catch (reporterError) {
+            queueMicrotask(() => {
+                throw new AggregateError([...errors, reporterError], 'replica diagnostic error reporter failed');
+            });
+        }
+    }
+}
+function boundedEventLimit(value) {
+    if (value === undefined)
+        return DEFAULT_MAX_EVENTS;
+    if (!Number.isSafeInteger(value) || value < 1 || value > MAX_EVENTS) {
+        throw new TypeError(`diagnostic maxEvents must be an integer between 1 and ${MAX_EVENTS}`);
+    }
+    return value;
+}
+function structuralStaleReason(value) {
+    switch (value) {
+        case 'application-stale':
+        case 'graphql-error':
+        case 'graphql-partial-error':
+        case 'incomplete-result':
+        case 'record-lifecycle-changed':
+        case 'revision-conflict':
+            return value;
+        default: {
+            const queryPlan = /^query-plan:([a-z][a-z0-9_]{0,63})(?::.*)?$/.exec(value);
+            return queryPlan === null
+                ? 'application-stale'
+                : `query-plan:${queryPlan[1]}`;
+        }
+    }
+}
+function structuralLayerReason(value) {
+    return value === 'retired-earlier-layer' ||
+        value === 'rejected-earlier-layer'
+        ? value
+        : 'application-layer-change';
+}
+function boundedDiagnosticReason(value, fallback) {
+    if (typeof value !== 'string') {
+        throw new TypeError('diagnostic reason redactor must return a string');
+    }
+    const normalized = value
+        .replace(/[\u0000-\u001f\u007f]/g, '\ufffd')
+        .trim();
+    if (normalized.length === 0)
+        return fallback;
+    return [...normalized].slice(0, MAX_REASON_LENGTH).join('');
+}
+function validCapability(capability) {
+    return (capability !== undefined &&
+        typeof capability === 'object' &&
+        developmentCapabilities.has(capability));
+}
+function validateScope(scope) {
+    if (!Number.isSafeInteger(scope.generation) || scope.generation < 0) {
+        throw new TypeError('diagnostic scope generation must be an unsigned integer');
+    }
+    if (scope.established) {
+        if (scope.protocolVersion !== 1 || !nonempty(scope.schemaHash)) {
+            throw new TypeError('established diagnostic scope requires protocol and schema hash');
+        }
+    }
+    else if (scope.protocolVersion !== undefined || scope.schemaHash !== undefined) {
+        throw new TypeError('unestablished diagnostic scope cannot carry protocol identity');
+    }
+}
+function freezeScope(scope) {
+    return Object.freeze({
+        generation: scope.generation,
+        established: scope.established,
+        ...(scope.protocolVersion === undefined
+            ? {}
+            : { protocolVersion: scope.protocolVersion }),
+        ...(scope.schemaHash === undefined ? {} : { schemaHash: scope.schemaHash })
+    });
+}
+function freezeCoverage(coverage) {
+    return Object.freeze({ ...coverage });
+}
+function freezeValueRecord(value, description, depth = 0) {
+    const entries = Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, entry]) => [
+        key,
+        cloneDiagnosticValue(entry, `${description}.${key}`, depth + 1)
+    ]);
+    return Object.freeze(Object.fromEntries(entries));
+}
+function cloneDiagnosticValue(value, description, depth = 0) {
+    if (depth > MAX_VALUE_DEPTH) {
+        throw new TypeError(`${description} exceeds diagnostic value depth`);
+    }
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'boolean' ||
+        (typeof value === 'number' && Number.isFinite(value))) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return Object.freeze(value.map((entry, index) => cloneDiagnosticValue(entry, `${description}[${index}]`, depth + 1)));
+    }
+    if (typeof value !== 'object') {
+        throw new TypeError(`${description} must be a JSON-compatible value`);
+    }
+    return freezeValueRecord(value, description, depth);
+}
+function nonempty(value) {
+    return typeof value === 'string' && value.length > 0;
+}

package/dist/replica/diagnostics/implementation.d.ts

@@ -0,0 +1,4 @@
+/** Re-export surface for diagnostics modules (body-split). */
+export * from './types.js';
+export * from './inspect.js';
+export * from './event-log.js';

package/dist/replica/diagnostics/implementation.js

@@ -0,0 +1,4 @@
+/** Re-export surface for diagnostics modules (body-split). */
+export * from './types.js';
+export * from './inspect.js';
+export * from './event-log.js';

package/dist/replica/diagnostics/index.d.ts

@@ -0,0 +1,2 @@
+export { createReplicaDevelopmentCapability, createReplicaDiagnostics, inspectReplicaCommandArtifact, inspectReplicaOperationArtifact } from './implementation.js';
+export type { ReplicaArtifactSourceLocation, ReplicaCommandArtifactInspection, ReplicaCommandEffectInspection, ReplicaDevelopmentCapability, ReplicaDiagnosticEvent, ReplicaDiagnosticEventInput, ReplicaDiagnosticFieldValueContext, ReplicaDiagnosticFieldValuePolicy, ReplicaDiagnosticIndex, ReplicaDiagnosticIndexInput, ReplicaDiagnosticLayer, ReplicaDiagnosticLayerInput, ReplicaDiagnosticReceipt, ReplicaDiagnosticReceiptExpectationInput, ReplicaDiagnosticReceiptInput, ReplicaDiagnosticRecord, ReplicaDiagnosticRecordInput, ReplicaDiagnosticReasonContext, ReplicaDiagnosticReasonPolicy, ReplicaDiagnostics, ReplicaDiagnosticsOptions, ReplicaDiagnosticsSink, ReplicaDiagnosticsSnapshot, ReplicaDiagnosticScopeInput, ReplicaDiagnosticStateInput, ReplicaOperationArtifactInspection, ReplicaOperationIndexInspection, ReplicaOperationInjectedFieldInspection } from './implementation.js';

package/dist/replica/diagnostics/index.js

@@ -0,0 +1 @@
+export { createReplicaDevelopmentCapability, createReplicaDiagnostics, inspectReplicaCommandArtifact, inspectReplicaOperationArtifact } from './implementation.js';

package/dist/replica/diagnostics/inspect.d.ts

@@ -0,0 +1,6 @@
+import type { GraphqlVariables } from '../../types.js';
+import type { ReplicaCommandArtifact } from '../commands.js';
+import type { ReplicaOperationArtifact } from '../types.js';
+import type { ReplicaCommandArtifactInspection, ReplicaOperationArtifactInspection } from './types.js';
+export declare function inspectReplicaOperationArtifact<TData, TVariables extends GraphqlVariables>(artifact: ReplicaOperationArtifact<TData, TVariables>): ReplicaOperationArtifactInspection;
+export declare function inspectReplicaCommandArtifact<TInput, TOutput>(artifact: ReplicaCommandArtifact<TInput, TOutput>): ReplicaCommandArtifactInspection;

package/dist/replica/diagnostics/inspect.js

@@ -0,0 +1,170 @@
+export function inspectReplicaOperationArtifact(artifact) {
+    const injected = [];
+    const dependencies = new Set();
+    const indexes = [];
+    for (const root of artifact.roots) {
+        const path = root.responseKey;
+        inspectRoot(root, path, injected, dependencies, indexes);
+    }
+    const source = safeArtifactSource(artifact.source);
+    return Object.freeze({
+        kind: 'operation',
+        id: artifact.id,
+        ...(source === undefined
+            ? {}
+            : {
+                source: Object.freeze({
+                    path: source.path,
+                    line: source.line,
+                    column: source.column
+                })
+            }),
+        rootFields: Object.freeze(artifact.roots.map((root) => root.field)),
+        injectedFields: Object.freeze(injected),
+        dependencies: Object.freeze([...dependencies].sort()),
+        indexes: Object.freeze(indexes),
+        ...(artifact.live === undefined
+            ? {}
+            : { live: Object.freeze({ operation: artifact.live.id }) })
+    });
+}
+export function inspectReplicaCommandArtifact(artifact) {
+    const effects = artifact.effects.operations.map((effect) => {
+        const models = new Set();
+        const fields = new Set();
+        const sources = new Set();
+        if ('model' in effect)
+            models.add(effect.model);
+        if ('relationship' in effect) {
+            models.add(effect.relationship.sourceModel);
+            models.add(effect.relationship.targetModel);
+            fields.add(effect.relationship.field);
+        }
+        if ('key' in effect) {
+            for (const field of effect.key.fields) {
+                fields.add(field.field);
+                sources.add(expressionSource(field.value));
+            }
+        }
+        if ('source' in effect) {
+            for (const field of effect.source.fields) {
+                fields.add(field.field);
+                sources.add(expressionSource(field.value));
+            }
+        }
+        if ('target' in effect) {
+            for (const field of effect.target.fields) {
+                fields.add(field.field);
+                sources.add(expressionSource(field.value));
+            }
+        }
+        if ('fields' in effect) {
+            for (const field of effect.fields) {
+                fields.add(field.field);
+                sources.add(expressionSource(field.value));
+            }
+        }
+        return Object.freeze({
+            kind: effect.kind,
+            models: Object.freeze([...models].sort()),
+            fields: Object.freeze([...fields].sort()),
+            valueSources: Object.freeze([...sources].sort())
+        });
+    });
+    return Object.freeze({
+        kind: 'command',
+        name: artifact.name,
+        operation: artifact.operationHash,
+        consistency: artifact.consistency,
+        effects: Object.freeze(effects),
+        revalidation: Object.freeze({
+            required: artifact.revalidation.required,
+            dependencies: Object.freeze([...artifact.revalidation.dependencies].sort()),
+            models: Object.freeze([...artifact.revalidation.models].sort())
+        })
+    });
+}
+function inspectRoot(root, path, injected, dependencies, indexes) {
+    for (const dependency of root.dependencies)
+        dependencies.add(dependency);
+    indexes.push(Object.freeze({
+        path,
+        field: root.field,
+        cardinality: root.cardinality,
+        dependencies: Object.freeze([...root.dependencies].sort()),
+        ...(root.coverage === undefined
+            ? {}
+            : { coverage: root.coverage.kind }),
+        filtered: root.filter !== undefined,
+        ordered: root.order !== undefined,
+        ...(root.pagination === undefined
+            ? {}
+            : { pagination: root.pagination.kind })
+    }));
+    inspectSelection(root.selection, path, injected, dependencies, indexes);
+}
+function safeArtifactSource(source) {
+    if (source === undefined)
+        return undefined;
+    const path = source.path;
+    const driveAbsolute = path.length >= 2 && path[1] === ':';
+    if (path.length === 0 ||
+        path.length > 4_096 ||
+        /[\u0000-\u001f\u007f]/.test(path) ||
+        path.startsWith('/') ||
+        driveAbsolute ||
+        path.includes('\\') ||
+        path.split('/').includes('..') ||
+        (!path.endsWith('.graphql') && !path.endsWith('.gql')) ||
+        !Number.isSafeInteger(source.line) ||
+        source.line < 1 ||
+        !Number.isSafeInteger(source.column) ||
+        source.column < 1) {
+        return undefined;
+    }
+    return Object.freeze({
+        path,
+        line: source.line,
+        column: source.column
+    });
+}
+function inspectSelection(selection, path, injected, dependencies, indexes) {
+    for (const member of selection.members) {
+        const memberPath = `${path}.${member.responseKey}`;
+        if (member.kind === 'scalar') {
+            if (member.expose === false) {
+                injected.push(Object.freeze({
+                    path: memberPath,
+                    responseKey: member.responseKey,
+                    field: member.field
+                }));
+            }
+            continue;
+        }
+        const indexDependencies = new Set([
+            ...member.dependencies,
+            ...(member.relationship?.dependencies ?? [])
+        ]);
+        for (const dependency of indexDependencies) {
+            dependencies.add(dependency);
+        }
+        indexes.push(Object.freeze({
+            path: memberPath,
+            field: member.field,
+            cardinality: member.cardinality,
+            dependencies: Object.freeze([...indexDependencies].sort()),
+            ...(member.coverage === undefined
+                ? {}
+                : { coverage: member.coverage.kind }),
+            filtered: member.filter !== undefined,
+            ordered: member.order !== undefined,
+            ...(member.pagination === undefined
+                ? {}
+                : { pagination: member.pagination.kind })
+        }));
+        inspectSelection(member.selection, memberPath, injected, dependencies, indexes);
+    }
+}
+function expressionSource(expression) {
+    return expression.kind;
+}