@oatscenter/trellis 0.100.0-rc.1

package/operations.js

@@ -0,0 +1,847 @@
+import { AsyncResult, err, isErr, ok } from "@oatscenter/result";
+import { ulid } from "ulid";
+import { parseUnknownSchema } from "./codec.js";
+import { getBuiltinRpcError, OperationAlreadyTerminalError, OperationMismatchError, OperationNotFoundError, TransferError, TransportError, UnexpectedError, } from "./errors/index.js";
+let activeJobWaitHook;
+/** @internal Registers the Jobs runtime hook used to track operation waits inside job handlers. */
+export function setActiveJobWaitHook(hook) {
+    activeJobWaitHook = hook;
+}
+function operationRequestBody(input, invocationId) {
+    return { invocationId, input: input };
+}
+function encodeOperationInput(schema, value) {
+    if (value === undefined || value === null || schema === undefined ||
+        schema === null) {
+        return value;
+    }
+    if (typeof Reflect.get(schema, "encode") === "function") {
+        return schema.encode(value);
+    }
+    return value;
+}
+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 "update":
+            await options.onUpdate?.(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.onUpdate ||
+        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, received ${JSON.stringify(value)}`);
+        }
+        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 {
+    id;
+    service;
+    operation;
+    #transport;
+    #descriptor;
+    #acceptedTransfer;
+    constructor(transport, descriptor, ref, acceptedTransfer) {
+        this.#transport = transport;
+        this.#descriptor = descriptor;
+        this.id = ref.id;
+        this.service = ref.service;
+        this.operation = ref.operation;
+        this.#acceptedTransfer = acceptedTransfer;
+    }
+    #decodePayload(schema, value) {
+        return decodeOperationPayload(schema, value);
+    }
+    #decodeSnapshot(snapshot) {
+        return decodeOperationSnapshot(this.#descriptor, snapshot);
+    }
+    #decodeEvent(event) {
+        const descriptor = this.#descriptor;
+        const decoded = event.snapshot === undefined
+            ? { ...event }
+            : { ...event, snapshot: this.#decodeSnapshot(event.snapshot) };
+        if (event.type === "progress") {
+            return {
+                ...decoded,
+                progress: this.#decodePayload(descriptor.progress, event.progress),
+            };
+        }
+        if (event.type === "update") {
+            return {
+                ...decoded,
+                update: this.#decodePayload(descriptor.update, event.update),
+            };
+        }
+        return decoded;
+    }
+    get() {
+        return this.#controlSnapshot("get");
+    }
+    wait() {
+        return AsyncResult.from((async () => {
+            const initialTerminal = await this.#terminalSnapshotFromGet().take();
+            if (isErr(initialTerminal)) {
+                return initialTerminal;
+            }
+            if (initialTerminal !== null) {
+                return ok(initialTerminal);
+            }
+            const eventsValue = await this.watch().take();
+            if (isErr(eventsValue)) {
+                const terminal = await this.#terminalSnapshotFromGet().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 this.#terminalSnapshotFromGet().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 this.#terminalSnapshotFromGet().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 },
+            }));
+        })());
+    }
+    #terminalSnapshotFromGet() {
+        return AsyncResult.from((async () => {
+            const snapshotValue = await this.#controlSnapshot("get").take();
+            if (isErr(snapshotValue)) {
+                return snapshotValue;
+            }
+            if (isTerminalState(snapshotValue.state)) {
+                return ok(snapshotValue);
+            }
+            return ok(null);
+        })());
+    }
+    cancel() {
+        return this.#controlSnapshot("cancel");
+    }
+    signal(signal, input) {
+        return AsyncResult.from((async () => {
+            const body = {
+                action: "signal",
+                operationId: this.id,
+                signal,
+            };
+            if (input !== undefined) {
+                const signals = this.#descriptor
+                    .signals;
+                body.input = encodeOperationInput(signals?.[signal], input);
+            }
+            const responseValue = await this.#transport.requestJson(controlSubject(this.#descriptor.subject), body).take();
+            if (isErr(responseValue)) {
+                return err(responseValue.error);
+            }
+            const ack = decodeSignalAckFrame(responseValue)
+                .take();
+            if (isErr(ack)) {
+                return ack;
+            }
+            return ok({ ...ack, snapshot: this.#decodeSnapshot(ack.snapshot) });
+        })());
+    }
+    startTransfer(body) {
+        const grant = this.#acceptedTransfer;
+        if (!grant) {
+            return AsyncResult.err(new TransferError({
+                operation: "transfer",
+                context: { reason: "missing_transfer" },
+            }));
+        }
+        return this.#transport.putTransfer(grant, body);
+    }
+    watch(options = {}) {
+        return AsyncResult.from((async () => {
+            const rawIterable = await this.#transport.watchJson(controlSubject(this.#descriptor.subject), {
+                action: "watch",
+                operationId: this.id,
+                ...(options.updates ? { includeUpdates: true } : {}),
+            }).take();
+            if (isErr(rawIterable)) {
+                return err(rawIterable.error);
+            }
+            const iterable = rawIterable;
+            const decodeEvent = this.#decodeEvent.bind(this);
+            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;
+                    }
+                    const event = decodeEvent(normalized);
+                    yield event;
+                    if (isTerminalEvent(event)) {
+                        break;
+                    }
+                }
+            }
+            return ok(events());
+        })());
+    }
+    #controlSnapshot(action) {
+        return AsyncResult.from((async () => {
+            const responseValue = await this.#transport.requestJson(controlSubject(this.#descriptor.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(this.#decodeSnapshot(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, invocationId) {
+    return AsyncResult.from((async () => {
+        const responseValue = await transport.requestJson(descriptor.subject, operationRequestBody(encodeOperationInput(descriptor.input, input), invocationId)).take();
+        if (isErr(responseValue)) {
+            return responseValue;
+        }
+        const envelope = decodeAcceptedEnvelope(responseValue)
+            .take();
+        if (isErr(envelope)) {
+            return envelope;
+        }
+        return ok({
+            accepted: {
+                type: "accepted",
+                snapshot: decodeOperationSnapshot(descriptor, 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({
+            updates: callbacks.onUpdate !== undefined,
+        }).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, options) {
+    return AsyncResult.from((async () => {
+        const startedValue = await invokeOperation(transport, descriptor, input, options?.invocationId ?? ulid()).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, options) {
+    return AsyncResult.from((async () => {
+        const startedValue = await invokeOperation(transport, descriptor, input, options?.invocationId ?? ulid()).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 transferredValue = await operation.startTransfer(body).take();
+        if (isErr(transferredValue)) {
+            await observation.close?.();
+            return transferredValue;
+        }
+        const publicOperation = createPublicOperationRef(operation, accepted.isErr() ? failedObservation(accepted.error) : observation);
+        return ok({
+            operation: publicOperation,
+            wait: () => AsyncResult.from((async () => {
+                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 () => {
+            const waited = activeJobWaitHook?.({
+                kind: "operation",
+                id: operation.id,
+                operationId: operation.id,
+                service: operation.service,
+                type: operation.operation,
+            }, 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();
+            });
+            if (waited)
+                return await waited;
+            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: (options) => operation.watch(options),
+        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 });
+        },
+        onUpdate(handler) {
+            return rebuild({ ...callbacks, onUpdate: 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, options) {
+            return startObservedOperation(transport, descriptor, input, { ...callbacks, ...startCallbacks }, options);
+        },
+    };
+    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 });
+        },
+        onUpdate(handler) {
+            return rebuild({ ...callbacks, onUpdate: 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, options) {
+            return startObservedTransfer(transport, descriptor, input, body, { ...callbacks, ...startCallbacks }, options);
+        },
+    };
+}
+export class OperationInvoker {
+    #transport;
+    #descriptor;
+    constructor(transport, descriptor) {
+        this.#transport = transport;
+        this.#descriptor = descriptor;
+    }
+    resume(ref) {
+        return createPublicOperationRef(new RuntimeOperationRef(this.#transport, this.#descriptor, ref), {});
+    }
+    start(input, callbacks) {
+        return createOperationInputBuilder(this.#transport, this.#descriptor, input).start(callbacks);
+    }
+    input(input) {
+        return createOperationInputBuilder(this.#transport, this.#descriptor, input);
+    }
+}
+function decodeOperationPayload(schema, value) {
+    if (value === undefined || value === null || schema === undefined ||
+        schema === null) {
+        return value;
+    }
+    if (typeof Reflect.get(schema, "decode") === "function") {
+        return schema.decode(value);
+    }
+    return value;
+}
+function decodeOperationSnapshot(descriptor, snapshot) {
+    if (!snapshot || typeof snapshot !== "object") {
+        return snapshot;
+    }
+    return {
+        ...snapshot,
+        ...(snapshot.progress === undefined ? {} : {
+            progress: decodeOperationPayload(descriptor.progress, snapshot.progress),
+        }),
+        ...(snapshot.output === undefined ? {} : {
+            output: decodeOperationPayload(descriptor.output, snapshot.output),
+        }),
+    };
+}
+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;
+}