@qlever-llc/trellis 0.10.3-rc.2 → 0.10.3

package/esm/npm/src/operations.js

@@ -1,775 +0,0 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _RuntimeOperationRef_instances, _RuntimeOperationRef_transport, _RuntimeOperationRef_descriptor, _RuntimeOperationRef_acceptedTransfer, _RuntimeOperationRef_terminalSnapshotFromGet, _RuntimeOperationRef_controlSnapshot, _OperationInvoker_transport, _OperationInvoker_descriptor;
-import { AsyncResult, err, isErr, ok } from "@qlever-llc/result";
-import { parseUnknownSchema } from "./codec.js";
-import { getBuiltinRpcError, OperationAlreadyTerminalError, OperationMismatchError, OperationNotFoundError, TransferError, TransportError, UnexpectedError, } from "./errors/index.js";
-function operationRequestBody(input) {
-    return input;
-}
-export function controlSubject(subject) {
-    return `${subject}.control`;
-}
-function isTerminalState(state) {
-    return state === "completed" || state === "failed" || state === "cancelled";
-}
-function createTransportError(args) {
-    return new TransportError({
-        code: args.code,
-        message: args.message,
-        hint: args.hint,
-        cause: args.cause,
-        context: {
-            ...(args.context ?? {}),
-            ...(args.cause instanceof Error
-                ? { causeName: args.cause.name, causeMessage: args.cause.message }
-                : args.cause === undefined
-                    ? {}
-                    : { cause: String(args.cause) }),
-        },
-    });
-}
-function snapshotToEvent(snapshot) {
-    switch (snapshot.state) {
-        case "pending":
-            return { type: "accepted", snapshot };
-        case "running":
-            return { type: "started", snapshot };
-        case "completed":
-            return {
-                type: "completed",
-                snapshot: snapshot,
-            };
-        case "failed":
-            return {
-                type: "failed",
-                snapshot: snapshot,
-            };
-        case "cancelled":
-            return {
-                type: "cancelled",
-                snapshot: snapshot,
-            };
-    }
-}
-function isTerminalEvent(event) {
-    return event.type === "completed" || event.type === "failed" ||
-        event.type === "cancelled";
-}
-function normalizeOperationEvent(event) {
-    try {
-        switch (event.type) {
-            case "transfer": {
-                const transfer = event.transfer ?? event.snapshot.transfer;
-                if (!transfer) {
-                    throw new Error("transfer event is missing transfer progress");
-                }
-                return ok({
-                    type: "transfer",
-                    transfer,
-                    snapshot: {
-                        ...event.snapshot,
-                        transfer,
-                    },
-                });
-            }
-            case "progress": {
-                const progress = event.progress ?? event.snapshot.progress;
-                if (progress === undefined) {
-                    throw new Error("progress event is missing progress payload");
-                }
-                return ok({
-                    type: "progress",
-                    progress,
-                    snapshot: {
-                        ...event.snapshot,
-                        progress,
-                    },
-                });
-            }
-            default:
-                return ok(event);
-        }
-    }
-    catch (cause) {
-        return err(createTransportError({
-            code: "trellis.operation.invalid_event",
-            message: "Trellis returned an invalid operation event.",
-            hint: "Retry the operation watch. If it keeps failing, reconnect to Trellis and try again.",
-            cause,
-        }));
-    }
-}
-async function dispatchObservedOperationEvent(options, event) {
-    switch (event.type) {
-        case "accepted":
-            await options.onAccepted?.(event);
-            break;
-        case "started":
-            await options.onStarted?.(event);
-            break;
-        case "transfer":
-            await options.onTransfer?.(event);
-            break;
-        case "progress":
-            await options.onProgress?.(event);
-            break;
-        case "completed":
-            await options.onCompleted?.(event);
-            break;
-        case "failed":
-            await options.onFailed?.(event);
-            break;
-        case "cancelled":
-            await options.onCancelled?.(event);
-            break;
-    }
-    await options.onEvent?.(event);
-}
-function hasObserverCallbacks(options) {
-    return Boolean(options.onAccepted ||
-        options.onStarted ||
-        options.onTransfer ||
-        options.onProgress ||
-        options.onCompleted ||
-        options.onFailed ||
-        options.onCancelled ||
-        options.onEvent);
-}
-function decodeAcceptedEnvelope(value) {
-    try {
-        const envelope = value;
-        if (envelope?.kind !== "accepted" || !envelope.ref || !envelope.snapshot) {
-            throw new Error(`Expected accepted operation envelope, got ${JSON.stringify(value)}`);
-        }
-        return ok(envelope);
-    }
-    catch (cause) {
-        return err(createTransportError({
-            code: "trellis.operation.invalid_accept",
-            message: "Trellis returned an invalid operation start response.",
-            hint: "Retry starting the operation. If it keeps failing, reconnect to Trellis and try again.",
-            cause,
-        }));
-    }
-}
-function decodeSnapshotFrame(value) {
-    try {
-        if (isOperationControlErrorFrame(value)) {
-            return err(controlFrameToError(value));
-        }
-        const frame = value;
-        if (frame?.kind !== "snapshot" || !frame.snapshot) {
-            throw new Error("Expected snapshot operation frame");
-        }
-        return ok(frame);
-    }
-    catch (cause) {
-        return err(createTransportError({
-            code: "trellis.operation.invalid_snapshot",
-            message: "Trellis returned an invalid operation snapshot.",
-            hint: "Retry the operation request. If it keeps failing, reconnect to Trellis and try again.",
-            cause,
-        }));
-    }
-}
-function decodeSignalAckFrame(value) {
-    try {
-        if (isOperationControlErrorFrame(value)) {
-            return err(controlFrameToError(value));
-        }
-        const frame = value;
-        if (frame?.kind !== "signal-accepted" ||
-            typeof frame.operationId !== "string" ||
-            typeof frame.signal !== "string" ||
-            typeof frame.signalSequence !== "number" ||
-            typeof frame.acceptedAt !== "string" ||
-            !frame.snapshot) {
-            throw new Error("Expected signal-accepted operation frame");
-        }
-        return ok(frame);
-    }
-    catch (cause) {
-        return err(createTransportError({
-            code: "trellis.operation.invalid_signal_ack",
-            message: "Trellis returned an invalid operation signal response.",
-            hint: "Retry the operation signal. If it keeps failing, reconnect to Trellis and try again.",
-            cause,
-        }));
-    }
-}
-class RuntimeOperationRef {
-    constructor(transport, descriptor, ref, acceptedTransfer) {
-        _RuntimeOperationRef_instances.add(this);
-        Object.defineProperty(this, "id", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "service", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "operation", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        _RuntimeOperationRef_transport.set(this, void 0);
-        _RuntimeOperationRef_descriptor.set(this, void 0);
-        _RuntimeOperationRef_acceptedTransfer.set(this, void 0);
-        __classPrivateFieldSet(this, _RuntimeOperationRef_transport, transport, "f");
-        __classPrivateFieldSet(this, _RuntimeOperationRef_descriptor, descriptor, "f");
-        this.id = ref.id;
-        this.service = ref.service;
-        this.operation = ref.operation;
-        __classPrivateFieldSet(this, _RuntimeOperationRef_acceptedTransfer, acceptedTransfer, "f");
-    }
-    get() {
-        return __classPrivateFieldGet(this, _RuntimeOperationRef_instances, "m", _RuntimeOperationRef_controlSnapshot).call(this, "get");
-    }
-    wait() {
-        return AsyncResult.from((async () => {
-            const initialTerminal = await __classPrivateFieldGet(this, _RuntimeOperationRef_instances, "m", _RuntimeOperationRef_terminalSnapshotFromGet).call(this).take();
-            if (isErr(initialTerminal)) {
-                return initialTerminal;
-            }
-            if (initialTerminal !== null) {
-                return ok(initialTerminal);
-            }
-            const eventsValue = await this.watch().take();
-            if (isErr(eventsValue)) {
-                const terminal = await __classPrivateFieldGet(this, _RuntimeOperationRef_instances, "m", _RuntimeOperationRef_terminalSnapshotFromGet).call(this).take();
-                if (!isErr(terminal) && terminal !== null) {
-                    return ok(terminal);
-                }
-                return eventsValue;
-            }
-            try {
-                for await (const event of eventsValue) {
-                    if (isTerminalEvent(event)) {
-                        return ok(event.snapshot);
-                    }
-                }
-            }
-            catch (cause) {
-                const terminal = await __classPrivateFieldGet(this, _RuntimeOperationRef_instances, "m", _RuntimeOperationRef_terminalSnapshotFromGet).call(this).take();
-                if (!isErr(terminal) && terminal !== null) {
-                    return ok(terminal);
-                }
-                return err(cause instanceof TransportError || cause instanceof UnexpectedError ||
-                    isOperationLifecycleError(cause)
-                    ? cause
-                    : new UnexpectedError({ cause }));
-            }
-            const terminal = await __classPrivateFieldGet(this, _RuntimeOperationRef_instances, "m", _RuntimeOperationRef_terminalSnapshotFromGet).call(this).take();
-            if (!isErr(terminal) && terminal !== null) {
-                return ok(terminal);
-            }
-            return err(createTransportError({
-                code: "trellis.operation.watch_closed",
-                message: "Trellis operation watch ended before a terminal snapshot.",
-                hint: "Retry the operation wait. If it keeps happening, reconnect to Trellis and try again.",
-                context: { operationId: this.id, operation: this.operation },
-            }));
-        })());
-    }
-    cancel() {
-        return __classPrivateFieldGet(this, _RuntimeOperationRef_instances, "m", _RuntimeOperationRef_controlSnapshot).call(this, "cancel");
-    }
-    signal(signal, input) {
-        return AsyncResult.from((async () => {
-            const body = {
-                action: "signal",
-                operationId: this.id,
-                signal,
-            };
-            if (input !== undefined) {
-                body.input = input;
-            }
-            const responseValue = await __classPrivateFieldGet(this, _RuntimeOperationRef_transport, "f").requestJson(controlSubject(__classPrivateFieldGet(this, _RuntimeOperationRef_descriptor, "f").subject), body).take();
-            if (isErr(responseValue)) {
-                return err(responseValue.error);
-            }
-            return decodeSignalAckFrame(responseValue);
-        })());
-    }
-    startTransfer(body) {
-        const grant = __classPrivateFieldGet(this, _RuntimeOperationRef_acceptedTransfer, "f");
-        if (!grant) {
-            return AsyncResult.err(new TransferError({
-                operation: "transfer",
-                context: { reason: "missing_transfer" },
-            }));
-        }
-        return __classPrivateFieldGet(this, _RuntimeOperationRef_transport, "f").putTransfer(grant, body);
-    }
-    watch() {
-        return AsyncResult.from((async () => {
-            const rawIterable = await __classPrivateFieldGet(this, _RuntimeOperationRef_transport, "f").watchJson(controlSubject(__classPrivateFieldGet(this, _RuntimeOperationRef_descriptor, "f").subject), {
-                action: "watch",
-                operationId: this.id,
-            }).take();
-            if (isErr(rawIterable)) {
-                return err(rawIterable.error);
-            }
-            const iterable = rawIterable;
-            async function* events() {
-                for await (const frame of iterable) {
-                    const frameValue = frame.take();
-                    if (isErr(frameValue)) {
-                        throw frameValue.error;
-                    }
-                    const decoded = decodeWatchFrame(frameValue);
-                    const decodedValue = decoded.take();
-                    if (isErr(decodedValue)) {
-                        throw decodedValue.error;
-                    }
-                    if (decodedValue === null) {
-                        continue;
-                    }
-                    const normalized = normalizeOperationEvent(decodedValue).take();
-                    if (isErr(normalized)) {
-                        throw normalized.error;
-                    }
-                    yield normalized;
-                    if (isTerminalEvent(normalized)) {
-                        break;
-                    }
-                }
-            }
-            return ok(events());
-        })());
-    }
-}
-_RuntimeOperationRef_transport = new WeakMap(), _RuntimeOperationRef_descriptor = new WeakMap(), _RuntimeOperationRef_acceptedTransfer = new WeakMap(), _RuntimeOperationRef_instances = new WeakSet(), _RuntimeOperationRef_terminalSnapshotFromGet = function _RuntimeOperationRef_terminalSnapshotFromGet() {
-    return AsyncResult.from((async () => {
-        const snapshotValue = await __classPrivateFieldGet(this, _RuntimeOperationRef_instances, "m", _RuntimeOperationRef_controlSnapshot).call(this, "get").take();
-        if (isErr(snapshotValue)) {
-            return snapshotValue;
-        }
-        if (isTerminalState(snapshotValue.state)) {
-            return ok(snapshotValue);
-        }
-        return ok(null);
-    })());
-}, _RuntimeOperationRef_controlSnapshot = function _RuntimeOperationRef_controlSnapshot(action) {
-    return AsyncResult.from((async () => {
-        const responseValue = await __classPrivateFieldGet(this, _RuntimeOperationRef_transport, "f").requestJson(controlSubject(__classPrivateFieldGet(this, _RuntimeOperationRef_descriptor, "f").subject), {
-            action,
-            operationId: this.id,
-        }).take();
-        if (isErr(responseValue)) {
-            return err(responseValue.error);
-        }
-        const frame = decodeSnapshotFrame(responseValue).take();
-        if (isErr(frame)) {
-            return frame;
-        }
-        return ok(frame.snapshot);
-    })());
-};
-function decodeWatchFrame(value) {
-    try {
-        if (value && typeof value === "object" &&
-            value.kind === "keepalive") {
-            return ok(null);
-        }
-        if (isOperationControlErrorFrame(value)) {
-            return err(controlFrameToError(value));
-        }
-        const frame = value;
-        if (frame.kind === "snapshot" && "snapshot" in frame) {
-            return ok(snapshotToEvent(frame.snapshot));
-        }
-        if (frame.kind === "event" && "event" in frame) {
-            return ok(frame.event);
-        }
-        throw new Error("Expected snapshot, event, or keepalive frame");
-    }
-    catch (cause) {
-        return err(createTransportError({
-            code: "trellis.operation.invalid_frame",
-            message: "Trellis returned an invalid operation watch frame.",
-            hint: "Retry the operation watch. If it keeps failing, reconnect to Trellis and try again.",
-            cause,
-        }));
-    }
-}
-function invokeOperation(transport, descriptor, input) {
-    return AsyncResult.from((async () => {
-        const responseValue = await transport.requestJson(descriptor.subject, operationRequestBody(input)).take();
-        if (isErr(responseValue)) {
-            return responseValue;
-        }
-        const envelope = decodeAcceptedEnvelope(responseValue)
-            .take();
-        if (isErr(envelope)) {
-            return envelope;
-        }
-        return ok({
-            accepted: {
-                type: "accepted",
-                snapshot: envelope.snapshot,
-            },
-            operation: new RuntimeOperationRef(transport, descriptor, envelope.ref, envelope.transfer),
-        });
-    })());
-}
-function beginObservedWatch(operation, callbacks, options = {}) {
-    if (!hasObserverCallbacks(callbacks)) {
-        return AsyncResult.ok({});
-    }
-    return AsyncResult.from((async () => {
-        const watchValue = await operation.watch().take();
-        if (isErr(watchValue)) {
-            return watchValue;
-        }
-        const iterator = watchValue[Symbol.asyncIterator]();
-        const close = async () => {
-            await iterator.return?.();
-        };
-        const task = (async () => {
-            try {
-                await options.ready;
-                while (true) {
-                    const next = await iterator.next();
-                    if (next.done) {
-                        break;
-                    }
-                    const event = next.value;
-                    if (options.skipEvent?.(event)) {
-                        continue;
-                    }
-                    try {
-                        await dispatchObservedOperationEvent(callbacks, event);
-                    }
-                    catch (cause) {
-                        return err(toObservedCallbackError(cause));
-                    }
-                    if (isTerminalEvent(event)) {
-                        await close();
-                        return ok(event.snapshot);
-                    }
-                }
-                return err(createTransportError({
-                    code: "trellis.operation.watch_incomplete",
-                    message: "Trellis ended the operation watch before completion.",
-                    hint: "Retry watching the operation. If it keeps happening, reconnect to Trellis and try again.",
-                    cause: new Error("operation watch ended before terminal event"),
-                }));
-            }
-            catch (cause) {
-                return err(cause instanceof TransportError || cause instanceof UnexpectedError ||
-                    isOperationLifecycleError(cause)
-                    ? cause
-                    : new UnexpectedError({ cause }));
-            }
-        })();
-        return ok({ task, close });
-    })());
-}
-function startObservedOperation(transport, descriptor, input, callbacks) {
-    return AsyncResult.from((async () => {
-        const startedValue = await invokeOperation(transport, descriptor, input).take();
-        if (isErr(startedValue)) {
-            return startedValue;
-        }
-        const ready = deferred();
-        const observedValue = await beginObservedWatch(startedValue.operation, callbacks, {
-            ready: ready.promise,
-            skipEvent: createAcceptedReplayFilter(startedValue.accepted),
-        }).take();
-        const observation = isErr(observedValue) ? {} : observedValue;
-        const accepted = await dispatchOperationEventResult(callbacks, startedValue.accepted);
-        if (accepted.isErr()) {
-            if (!isErr(observedValue)) {
-                ready.resolve();
-                await observation.close?.();
-            }
-            return ok(createPublicOperationRef(startedValue.operation, failedObservation(accepted.error)));
-        }
-        if (!isErr(observedValue)) {
-            ready.resolve();
-        }
-        return ok(createPublicOperationRef(startedValue.operation, observation));
-    })());
-}
-function startObservedTransfer(transport, descriptor, input, body, callbacks) {
-    return AsyncResult.from((async () => {
-        const startedValue = await invokeOperation(transport, descriptor, input).take();
-        if (isErr(startedValue)) {
-            return startedValue;
-        }
-        const operation = startedValue.operation;
-        const ready = deferred();
-        const observedValue = await beginObservedWatch(operation, callbacks, {
-            ready: ready.promise,
-            skipEvent: createAcceptedReplayFilter(startedValue.accepted),
-        }).take();
-        const observation = isErr(observedValue) ? {} : observedValue;
-        const accepted = await dispatchOperationEventResult(callbacks, startedValue.accepted);
-        if (accepted.isErr()) {
-            if (!isErr(observedValue)) {
-                ready.resolve();
-                await observation.close?.();
-            }
-        }
-        if (!isErr(observedValue)) {
-            ready.resolve();
-        }
-        const transferTask = (async () => {
-            const transferredValue = await operation.startTransfer(body).take();
-            if (isErr(transferredValue)) {
-                await observation.close?.();
-                return transferredValue;
-            }
-            return ok(transferredValue);
-        })();
-        const publicOperation = createPublicOperationRef(operation, accepted.isErr() ? failedObservation(accepted.error) : observation);
-        return ok({
-            operation: publicOperation,
-            wait: () => AsyncResult.from((async () => {
-                const transferred = await transferTask;
-                const transferredValue = transferred.take();
-                if (isErr(transferredValue)) {
-                    return transferredValue;
-                }
-                const terminalValue = await publicOperation.wait().take();
-                if (isErr(terminalValue)) {
-                    return terminalValue;
-                }
-                return ok({
-                    transferred: transferredValue,
-                    terminal: terminalValue,
-                });
-            })()),
-        });
-    })());
-}
-function createObservedOperationRef(operation, observation) {
-    return createPublicOperationRef(operation, observation);
-}
-function createPublicOperationRef(operation, observation) {
-    const base = {
-        id: operation.id,
-        service: operation.service,
-        operation: operation.operation,
-        get: () => operation.get(),
-        wait: () => AsyncResult.from((async () => {
-            if (observation.task) {
-                const terminal = await observation.task;
-                const terminalValue = terminal.take();
-                if (!isErr(terminalValue)) {
-                    return ok(terminalValue);
-                }
-                if (isObservedCallbackError(terminalValue.error)) {
-                    return terminalValue;
-                }
-            }
-            return await operation.wait();
-        })()),
-        watch: () => operation.watch(),
-        cancel: () => operation.cancel(),
-        signal: (signal, input) => operation.signal(signal, input),
-    };
-    return base;
-}
-function createOperationInputBuilder(transport, descriptor, input, callbacks = {}) {
-    const rebuild = (nextCallbacks) => createOperationInputBuilder(transport, descriptor, input, nextCallbacks);
-    const baseBuilder = {
-        onAccepted(handler) {
-            return rebuild({ ...callbacks, onAccepted: handler });
-        },
-        onStarted(handler) {
-            return rebuild({ ...callbacks, onStarted: handler });
-        },
-        onProgress(handler) {
-            return rebuild({ ...callbacks, onProgress: handler });
-        },
-        onCompleted(handler) {
-            return rebuild({ ...callbacks, onCompleted: handler });
-        },
-        onFailed(handler) {
-            return rebuild({ ...callbacks, onFailed: handler });
-        },
-        onCancelled(handler) {
-            return rebuild({ ...callbacks, onCancelled: handler });
-        },
-        onEvent(handler) {
-            return rebuild({ ...callbacks, onEvent: handler });
-        },
-        start(startCallbacks) {
-            return startObservedOperation(transport, descriptor, input, { ...callbacks, ...startCallbacks });
-        },
-    };
-    if (descriptor.transfer) {
-        return {
-            ...baseBuilder,
-            transfer(body) {
-                return createTransferOperationBuilder(transport, descriptor, input, body, callbacks);
-            },
-        };
-    }
-    return baseBuilder;
-}
-function createTransferOperationBuilder(transport, descriptor, input, body, callbacks = {}) {
-    const rebuild = (nextCallbacks) => createTransferOperationBuilder(transport, descriptor, input, body, nextCallbacks);
-    return {
-        onAccepted(handler) {
-            return rebuild({ ...callbacks, onAccepted: handler });
-        },
-        onStarted(handler) {
-            return rebuild({ ...callbacks, onStarted: handler });
-        },
-        onTransfer(handler) {
-            return rebuild({ ...callbacks, onTransfer: handler });
-        },
-        onProgress(handler) {
-            return rebuild({ ...callbacks, onProgress: handler });
-        },
-        onCompleted(handler) {
-            return rebuild({ ...callbacks, onCompleted: handler });
-        },
-        onFailed(handler) {
-            return rebuild({ ...callbacks, onFailed: handler });
-        },
-        onCancelled(handler) {
-            return rebuild({ ...callbacks, onCancelled: handler });
-        },
-        onEvent(handler) {
-            return rebuild({ ...callbacks, onEvent: handler });
-        },
-        start(startCallbacks) {
-            return startObservedTransfer(transport, descriptor, input, body, { ...callbacks, ...startCallbacks });
-        },
-    };
-}
-export class OperationInvoker {
-    constructor(transport, descriptor) {
-        _OperationInvoker_transport.set(this, void 0);
-        _OperationInvoker_descriptor.set(this, void 0);
-        __classPrivateFieldSet(this, _OperationInvoker_transport, transport, "f");
-        __classPrivateFieldSet(this, _OperationInvoker_descriptor, descriptor, "f");
-    }
-    resume(ref) {
-        return createPublicOperationRef(new RuntimeOperationRef(__classPrivateFieldGet(this, _OperationInvoker_transport, "f"), __classPrivateFieldGet(this, _OperationInvoker_descriptor, "f"), ref), {});
-    }
-    start(input, callbacks) {
-        return createOperationInputBuilder(__classPrivateFieldGet(this, _OperationInvoker_transport, "f"), __classPrivateFieldGet(this, _OperationInvoker_descriptor, "f"), input).start(callbacks);
-    }
-    input(input) {
-        return createOperationInputBuilder(__classPrivateFieldGet(this, _OperationInvoker_transport, "f"), __classPrivateFieldGet(this, _OperationInvoker_descriptor, "f"), input);
-    }
-}
-_OperationInvoker_transport = new WeakMap(), _OperationInvoker_descriptor = new WeakMap();
-function isOperationControlErrorFrame(value) {
-    return !!value && typeof value === "object" &&
-        value.kind === "error" &&
-        typeof Reflect.get(value, "error") === "object";
-}
-function controlFrameToError(frame) {
-    const lifecycleError = controlFrameToLifecycleError(frame);
-    if (lifecycleError) {
-        return lifecycleError;
-    }
-    return createTransportError({
-        code: "trellis.operation.control_error",
-        message: "Trellis rejected the operation control request.",
-        hint: "Check the operation state, then retry the action if it still applies.",
-        context: {
-            controlErrorType: frame.error.type,
-            controlErrorMessage: frame.error.message,
-        },
-    });
-}
-function controlFrameToLifecycleError(frame) {
-    if (!isFullOperationLifecycleErrorData(frame.error)) {
-        return undefined;
-    }
-    const descriptor = getBuiltinRpcError(frame.error.type);
-    if (!descriptor?.schema) {
-        return undefined;
-    }
-    const parsed = parseUnknownSchema(descriptor.schema, frame.error).take();
-    if (isErr(parsed)) {
-        return undefined;
-    }
-    const error = descriptor.fromSerializable(parsed);
-    return isOperationLifecycleError(error) ? error : undefined;
-}
-function isOperationLifecycleError(error) {
-    return error instanceof OperationNotFoundError ||
-        error instanceof OperationAlreadyTerminalError ||
-        error instanceof OperationMismatchError;
-}
-function isFullOperationLifecycleErrorData(error) {
-    if (typeof Reflect.get(error, "id") !== "string") {
-        return false;
-    }
-    switch (error.type) {
-        case "OperationNotFoundError":
-        case "OperationAlreadyTerminalError":
-            return typeof Reflect.get(error, "operationId") === "string";
-        case "OperationMismatchError":
-            return typeof Reflect.get(error, "operationId") === "string" &&
-                typeof Reflect.get(error, "expectedService") === "string" &&
-                typeof Reflect.get(error, "expectedOperation") === "string";
-        default:
-            return false;
-    }
-}
-function deferred() {
-    let resolve;
-    const promise = new Promise((r) => {
-        resolve = r;
-    });
-    return { promise, resolve };
-}
-function createAcceptedReplayFilter(accepted) {
-    return (event) => {
-        return event.type === "accepted" &&
-            event.snapshot.id === accepted.snapshot.id &&
-            event.snapshot.service === accepted.snapshot.service &&
-            event.snapshot.operation === accepted.snapshot.operation &&
-            event.snapshot.revision === accepted.snapshot.revision &&
-            event.snapshot.state === accepted.snapshot.state;
-    };
-}
-function failedObservation(error) {
-    return {
-        task: Promise.resolve(err(error)),
-    };
-}
-async function dispatchOperationEventResult(callbacks, event) {
-    try {
-        await dispatchObservedOperationEvent(callbacks, event);
-        return ok(undefined);
-    }
-    catch (cause) {
-        return err(toObservedCallbackError(cause));
-    }
-}
-function toObservedCallbackError(cause) {
-    return (cause instanceof UnexpectedError
-        ? cause
-        : new UnexpectedError({ cause }))
-        .withContext({ operationObserverCallback: true });
-}
-function isObservedCallbackError(error) {
-    return error instanceof UnexpectedError &&
-        error.getContext().operationObserverCallback === true;
-}