@qlever-llc/trellis 0.7.0 → 0.8.0-rc.3

package/script/npm/src/operations.js

@@ -0,0 +1,669 @@
+"use strict";
+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_controlSnapshot, _OperationInvoker_transport, _OperationInvoker_descriptor;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationInvoker = void 0;
+exports.controlSubject = controlSubject;
+const result_1 = require("@qlever-llc/result");
+const index_js_1 = require("./errors/index.js");
+function operationRequestBody(input) {
+    return input;
+}
+function controlSubject(subject) {
+    return `${subject}.control`;
+}
+function isTerminalState(state) {
+    return state === "completed" || state === "failed" || state === "cancelled";
+}
+function createTransportError(args) {
+    return new index_js_1.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 (0, result_1.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 (0, result_1.ok)({
+                    type: "progress",
+                    progress,
+                    snapshot: {
+                        ...event.snapshot,
+                        progress,
+                    },
+                });
+            }
+            default:
+                return (0, result_1.ok)(event);
+        }
+    }
+    catch (cause) {
+        return (0, result_1.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 (0, result_1.ok)(envelope);
+    }
+    catch (cause) {
+        return (0, result_1.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 (0, result_1.err)(controlFrameToTransportError(value));
+        }
+        const frame = value;
+        if (frame?.kind !== "snapshot" || !frame.snapshot) {
+            throw new Error("Expected snapshot operation frame");
+        }
+        return (0, result_1.ok)(frame);
+    }
+    catch (cause) {
+        return (0, result_1.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,
+        }));
+    }
+}
+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");
+    }
+    isCancelable() {
+        return __classPrivateFieldGet(this, _RuntimeOperationRef_descriptor, "f").cancel === true;
+    }
+    get() {
+        return __classPrivateFieldGet(this, _RuntimeOperationRef_instances, "m", _RuntimeOperationRef_controlSnapshot).call(this, "get");
+    }
+    wait() {
+        return result_1.AsyncResult.from((async () => {
+            const snapshotValue = await __classPrivateFieldGet(this, _RuntimeOperationRef_instances, "m", _RuntimeOperationRef_controlSnapshot).call(this, "get").take();
+            if ((0, result_1.isErr)(snapshotValue)) {
+                return snapshotValue;
+            }
+            if (isTerminalState(snapshotValue.state)) {
+                return (0, result_1.ok)(snapshotValue);
+            }
+            const eventsValue = await this.watch().take();
+            if ((0, result_1.isErr)(eventsValue)) {
+                return eventsValue;
+            }
+            for await (const event of eventsValue) {
+                if (isTerminalEvent(event)) {
+                    return (0, result_1.ok)(event.snapshot);
+                }
+            }
+            return (0, result_1.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");
+    }
+    startTransfer(body) {
+        const grant = __classPrivateFieldGet(this, _RuntimeOperationRef_acceptedTransfer, "f");
+        if (!grant) {
+            return result_1.AsyncResult.err(new index_js_1.TransferError({
+                operation: "transfer",
+                context: { reason: "missing_transfer" },
+            }));
+        }
+        return __classPrivateFieldGet(this, _RuntimeOperationRef_transport, "f").putTransfer(grant, body);
+    }
+    watch() {
+        return result_1.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 ((0, result_1.isErr)(rawIterable)) {
+                return (0, result_1.err)(rawIterable.error);
+            }
+            const iterable = rawIterable;
+            async function* events() {
+                for await (const frame of iterable) {
+                    const frameValue = frame.take();
+                    if ((0, result_1.isErr)(frameValue)) {
+                        throw frameValue.error;
+                    }
+                    const decoded = decodeWatchFrame(frameValue);
+                    const decodedValue = decoded.take();
+                    if ((0, result_1.isErr)(decodedValue)) {
+                        throw decodedValue.error;
+                    }
+                    if (decodedValue === null) {
+                        continue;
+                    }
+                    const normalized = normalizeOperationEvent(decodedValue).take();
+                    if ((0, result_1.isErr)(normalized)) {
+                        throw normalized.error;
+                    }
+                    yield normalized;
+                    if (isTerminalEvent(normalized)) {
+                        break;
+                    }
+                }
+            }
+            return (0, result_1.ok)(events());
+        })());
+    }
+}
+_RuntimeOperationRef_transport = new WeakMap(), _RuntimeOperationRef_descriptor = new WeakMap(), _RuntimeOperationRef_acceptedTransfer = new WeakMap(), _RuntimeOperationRef_instances = new WeakSet(), _RuntimeOperationRef_controlSnapshot = function _RuntimeOperationRef_controlSnapshot(action) {
+    return result_1.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 ((0, result_1.isErr)(responseValue)) {
+            return responseValue;
+        }
+        const frame = decodeSnapshotFrame(responseValue).take();
+        if ((0, result_1.isErr)(frame)) {
+            return frame;
+        }
+        return (0, result_1.ok)(frame.snapshot);
+    })());
+};
+function decodeWatchFrame(value) {
+    try {
+        if (value && typeof value === "object" &&
+            value.kind === "keepalive") {
+            return (0, result_1.ok)(null);
+        }
+        if (isOperationControlErrorFrame(value)) {
+            return (0, result_1.err)(controlFrameToTransportError(value));
+        }
+        const frame = value;
+        if (frame.kind === "snapshot" && "snapshot" in frame) {
+            return (0, result_1.ok)(snapshotToEvent(frame.snapshot));
+        }
+        if (frame.kind === "event" && "event" in frame) {
+            return (0, result_1.ok)(frame.event);
+        }
+        throw new Error("Expected snapshot, event, or keepalive frame");
+    }
+    catch (cause) {
+        return (0, result_1.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 result_1.AsyncResult.from((async () => {
+        const responseValue = await transport.requestJson(descriptor.subject, operationRequestBody(input)).take();
+        if ((0, result_1.isErr)(responseValue)) {
+            return responseValue;
+        }
+        const envelope = decodeAcceptedEnvelope(responseValue)
+            .take();
+        if ((0, result_1.isErr)(envelope)) {
+            return envelope;
+        }
+        return (0, result_1.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 result_1.AsyncResult.ok({});
+    }
+    return result_1.AsyncResult.from((async () => {
+        const watchValue = await operation.watch().take();
+        if ((0, result_1.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 (0, result_1.err)(toObservedCallbackError(cause));
+                    }
+                    if (isTerminalEvent(event)) {
+                        await close();
+                        return (0, result_1.ok)(event.snapshot);
+                    }
+                }
+                return (0, result_1.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 (0, result_1.err)(cause instanceof index_js_1.TransportError || cause instanceof index_js_1.UnexpectedError
+                    ? cause
+                    : new index_js_1.UnexpectedError({ cause }));
+            }
+        })();
+        return (0, result_1.ok)({ task, close });
+    })());
+}
+function startObservedOperation(transport, descriptor, input, callbacks) {
+    return result_1.AsyncResult.from((async () => {
+        const startedValue = await invokeOperation(transport, descriptor, input).take();
+        if ((0, result_1.isErr)(startedValue)) {
+            return startedValue;
+        }
+        const ready = deferred();
+        const observedValue = await beginObservedWatch(startedValue.operation, callbacks, {
+            ready: ready.promise,
+            skipEvent: createAcceptedReplayFilter(startedValue.accepted),
+        }).take();
+        const observation = (0, result_1.isErr)(observedValue) ? {} : observedValue;
+        const accepted = await dispatchOperationEventResult(callbacks, startedValue.accepted);
+        if (accepted.isErr()) {
+            if (!(0, result_1.isErr)(observedValue)) {
+                ready.resolve();
+                await observation.close?.();
+            }
+            return (0, result_1.ok)(createPublicOperationRef(startedValue.operation, failedObservation(accepted.error)));
+        }
+        if (!(0, result_1.isErr)(observedValue)) {
+            ready.resolve();
+        }
+        return (0, result_1.ok)(createPublicOperationRef(startedValue.operation, observation));
+    })());
+}
+function startObservedTransfer(transport, descriptor, input, body, callbacks) {
+    return result_1.AsyncResult.from((async () => {
+        const startedValue = await invokeOperation(transport, descriptor, input).take();
+        if ((0, result_1.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 = (0, result_1.isErr)(observedValue) ? {} : observedValue;
+        const accepted = await dispatchOperationEventResult(callbacks, startedValue.accepted);
+        if (accepted.isErr()) {
+            if (!(0, result_1.isErr)(observedValue)) {
+                ready.resolve();
+                await observation.close?.();
+            }
+        }
+        if (!(0, result_1.isErr)(observedValue)) {
+            ready.resolve();
+        }
+        const transferTask = (async () => {
+            const transferredValue = await operation.startTransfer(body).take();
+            if ((0, result_1.isErr)(transferredValue)) {
+                await observation.close?.();
+                return transferredValue;
+            }
+            return (0, result_1.ok)(transferredValue);
+        })();
+        const publicOperation = createPublicOperationRef(operation, accepted.isErr() ? failedObservation(accepted.error) : observation);
+        return (0, result_1.ok)({
+            operation: publicOperation,
+            wait: () => result_1.AsyncResult.from((async () => {
+                const transferred = await transferTask;
+                const transferredValue = transferred.take();
+                if ((0, result_1.isErr)(transferredValue)) {
+                    return transferredValue;
+                }
+                const terminalValue = await publicOperation.wait().take();
+                if ((0, result_1.isErr)(terminalValue)) {
+                    return terminalValue;
+                }
+                return (0, result_1.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: () => result_1.AsyncResult.from((async () => {
+            if (observation.task) {
+                const terminal = await observation.task;
+                const terminalValue = terminal.take();
+                if (!(0, result_1.isErr)(terminalValue)) {
+                    return (0, result_1.ok)(terminalValue);
+                }
+                if (isObservedCallbackError(terminalValue.error)) {
+                    return terminalValue;
+                }
+            }
+            return await operation.wait();
+        })()),
+        watch: () => operation.watch(),
+    };
+    if (!operation.isCancelable()) {
+        return base;
+    }
+    return {
+        ...base,
+        cancel: () => operation.cancel(),
+    };
+}
+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() {
+            return startObservedOperation(transport, descriptor, input, callbacks);
+        },
+    };
+    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() {
+            return startObservedTransfer(transport, descriptor, input, body, callbacks);
+        },
+    };
+}
+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), {});
+    }
+    input(input) {
+        return createOperationInputBuilder(__classPrivateFieldGet(this, _OperationInvoker_transport, "f"), __classPrivateFieldGet(this, _OperationInvoker_descriptor, "f"), input);
+    }
+}
+exports.OperationInvoker = OperationInvoker;
+_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 controlFrameToTransportError(frame) {
+    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 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((0, result_1.err)(error)),
+    };
+}
+async function dispatchOperationEventResult(callbacks, event) {
+    try {
+        await dispatchObservedOperationEvent(callbacks, event);
+        return (0, result_1.ok)(undefined);
+    }
+    catch (cause) {
+        return (0, result_1.err)(toObservedCallbackError(cause));
+    }
+}
+function toObservedCallbackError(cause) {
+    return (cause instanceof index_js_1.UnexpectedError
+        ? cause
+        : new index_js_1.UnexpectedError({ cause }))
+        .withContext({ operationObserverCallback: true });
+}
+function isObservedCallbackError(error) {
+    return error instanceof index_js_1.UnexpectedError &&
+        error.getContext().operationObserverCallback === true;
+}

package/script/npm/src/runtime_transport.d.ts

@@ -0,0 +1,23 @@
+import type { Authenticator, NatsConnection } from "@nats-io/nats-core";
+type RuntimeTransportEndpoints = {
+    natsServers: string[];
+};
+type RuntimeTransports = {
+    native?: RuntimeTransportEndpoints;
+    websocket?: RuntimeTransportEndpoints;
+};
+export declare const DEFAULT_RUNTIME_MAX_RECONNECT_ATTEMPTS = -1;
+export type RuntimeTransportConnectOptions = {
+    servers: string | string[];
+    token?: string;
+    authenticator?: Authenticator | Authenticator[];
+    inboxPrefix?: string;
+    maxReconnectAttempts?: number;
+} & Record<string, unknown>;
+export type RuntimeTransport = {
+    connect(options: RuntimeTransportConnectOptions): Promise<NatsConnection>;
+};
+export declare function selectRuntimeTransportServers(transports: RuntimeTransports): string[];
+export declare function loadDefaultRuntimeTransport(): Promise<RuntimeTransport>;
+export {};
+//# sourceMappingURL=runtime_transport.d.ts.map

package/script/npm/src/runtime_transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime_transport.d.ts","sourceRoot":"","sources":["../../../src/runtime_transport.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAExE,KAAK,yBAAyB,GAAG;IAC/B,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAEF,KAAK,iBAAiB,GAAG;IACvB,MAAM,CAAC,EAAE,yBAAyB,CAAC;IACnC,SAAS,CAAC,EAAE,yBAAyB,CAAC;CACvC,CAAC;AAEF,eAAO,MAAM,sCAAsC,KAAK,CAAC;AAEzD,MAAM,MAAM,8BAA8B,GAAG;IAC3C,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,aAAa,GAAG,aAAa,EAAE,CAAC;IAChD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE5B,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,CAAC,OAAO,EAAE,8BAA8B,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CAC3E,CAAC;AAEF,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,iBAAiB,GAC5B,MAAM,EAAE,CAkBV;AAoBD,wBAAsB,2BAA2B,IAAI,OAAO,CAAC,gBAAgB,CAAC,CA8B7E"}