@deksden-com/dd-flow-cli 0.9.0-beta.16 → 0.9.0-beta.160

package/dist/harness-runtime/vendor/opencode-client/chunks/service-probe-t1xa31vm.js

@@ -0,0 +1,39 @@
+import {
+  __export
+} from "./service-probe-9rqn6x4v.js";
+
+// src/rpc-runtime.ts
+var exports_rpc_runtime = {};
+__export(exports_rpc_runtime, {
+  RpcRuntime: () => exports_rpc_runtime,
+  event: () => event2,
+  eventType: () => eventType2,
+  read: () => read2,
+  readError: () => readError2
+});
+import { RpcError, RpcInternalError } from "@opencode/protocol/errors";
+import { Effect, Schema } from "effect";
+function read2(schema, value) {
+  return Schema.isSchema(schema) ? Schema.decodeUnknownEffect(schema)(value) : Effect.succeed(value);
+}
+function readError2(method, error) {
+  if (!(error instanceof RpcError) && !(error instanceof RpcInternalError))
+    return Effect.fail(error);
+  if (!method.errors || !Object.hasOwn(method.errors, error.type)) {
+    return Effect.fail(error.data === undefined ? { type: error.type, message: error.message } : { type: error.type, message: error.message, data: error.data });
+  }
+  return read2(method.errors[error.type], error.data).pipe(Effect.catch((cause) => Effect.die(cause)), Effect.flatMap((data) => Effect.fail(data === undefined ? { type: error.type, message: error.message } : { type: error.type, message: error.message, data })));
+}
+var event2 = Effect.fn("Client.Rpc.event")(function* (definition, name, schema, event) {
+  const data = yield* read2(schema.schema, event.data);
+  return {
+    ...event,
+    type: eventType2(definition, name),
+    data
+  };
+});
+function eventType2(definition, name) {
+  return `rpc.${definition.id}.${name}`;
+}
+
+export { read2, readError2, event2, eventType2, exports_rpc_runtime };

package/dist/harness-runtime/vendor/opencode-client/chunks/service-probe-ve4aws36.js

@@ -0,0 +1,103 @@
+// src/service-contender.ts
+import { spawn } from "node:child_process";
+var stderrLimit = 8 * 1024;
+function spawnServiceContender2(command, args, env) {
+  const child = spawn(command, args, {
+    detached: true,
+    windowsHide: true,
+    stdio: ["ignore", "ignore", "pipe"],
+    env: { ...process.env, ...env }
+  });
+  let error;
+  let closed = false;
+  let stderr = Buffer.alloc(0);
+  const onStderr = (chunk) => {
+    const tail = chunk.subarray(-stderrLimit);
+    stderr = tail.length === stderrLimit ? Buffer.from(tail) : Buffer.concat([stderr.subarray(-(stderrLimit - tail.length)), tail]);
+  };
+  child.stderr?.on("data", onStderr);
+  if (child.stderr !== null && "unref" in child.stderr && typeof child.stderr.unref === "function")
+    child.stderr.unref();
+  child.once("error", (cause) => {
+    error = new Error("Failed to start server", { cause });
+  });
+  child.once("close", () => {
+    closed = true;
+  });
+  child.unref();
+  return {
+    child,
+    error: () => error,
+    closed: () => closed,
+    stderr: () => stderr.toString("utf8").trim(),
+    release: () => {
+      child.stderr?.off("data", onStderr);
+      child.stderr?.resume();
+      stderr = Buffer.alloc(0);
+    }
+  };
+}
+function contenderPool2(timing) {
+  const contenders = new Set;
+  let failure;
+  let spawnDelay = timing.spawnDelay;
+  let lastSpawn = 0;
+  return {
+    failure: () => failure,
+    serviceAnswered() {
+      spawnDelay = timing.spawnDelay;
+    },
+    evict(pid) {
+      for (const item of contenders) {
+        if (item.child.pid === pid || contenderFinished2(item)) {
+          item.release();
+          contenders.delete(item);
+        }
+      }
+      failure = undefined;
+      lastSpawn = 0;
+    },
+    recruitNow() {
+      lastSpawn = Date.now() - spawnDelay;
+    },
+    reap() {
+      const finished = [...contenders].filter(contenderFinished2);
+      failure ??= finished.map(contenderFailure).find((error) => error !== undefined);
+      if (finished.some((item) => item.child.exitCode === 0))
+        spawnDelay = Math.min(spawnDelay * 2, timing.maxSpawnDelay);
+      finished.forEach((item) => contenders.delete(item));
+      return contenders.size === 0 ? failure : undefined;
+    },
+    shouldRecruit(registered) {
+      if (lastSpawn === 0 && registered)
+        lastSpawn = Date.now();
+      return failure === undefined && contenders.size < 2 && Date.now() - lastSpawn >= spawnDelay;
+    },
+    add(contender) {
+      contenders.add(contender);
+      lastSpawn = Date.now();
+    },
+    releaseAll() {
+      contenders.forEach((contender) => contender.release());
+    }
+  };
+}
+function contenderFailure(contender) {
+  const error = contender.error();
+  if (error !== undefined)
+    return error;
+  if (contender.child.exitCode !== null && contender.child.exitCode !== 0)
+    return startupError(`Server process exited with code ${contender.child.exitCode}`, contender.stderr());
+  if (contender.child.signalCode !== null)
+    return startupError(`Server process terminated by ${contender.child.signalCode}`, contender.stderr());
+  return;
+}
+function contenderFinished2(contender) {
+  return contender.error() !== undefined || contender.closed();
+}
+function startupError(message, stderr) {
+  return new Error(stderr ? `${message}
+${stderr}` : message);
+}
+
+export { spawnServiceContender2, contenderPool2, contenderFinished2 };

package/dist/harness-runtime/vendor/opencode-client/chunks/service-probe-vmytr4q8.js

@@ -0,0 +1,4 @@
+// src/contract.ts
+import { ClientApi as ClientApi2, effectOmitEndpoints as effectOmitEndpoints2, groupNames as groupNames2, promiseOmitEndpoints as promiseOmitEndpoints2 } from "@opencode/protocol/client";
+
+export { ClientApi2, effectOmitEndpoints2, groupNames2, promiseOmitEndpoints2 };

package/dist/harness-runtime/vendor/opencode-client/chunks/service-probe-vt9jbch8.js

@@ -0,0 +1,36 @@
+// src/promise/generated/types.ts
+var isInvalidRequestError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "InvalidRequestError";
+var isUnauthorizedError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "UnauthorizedError";
+var isLocationNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "LocationNotFoundError";
+var isServiceUnavailableError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "ServiceUnavailableError";
+var isAgentNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "AgentNotFoundError";
+var isInvalidCursorError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "InvalidCursorError";
+var isSessionNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "SessionNotFoundError";
+var isConflictError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "ConflictError";
+var isUnknownError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "UnknownError";
+var isMessageNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "MessageNotFoundError";
+var isCommandNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "CommandNotFoundError";
+var isCommandExecutionError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "CommandExecutionError";
+var isSkillNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "SkillNotFoundError";
+var isSessionBusyError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "SessionBusyError";
+var isInstructionEntryValueTooLargeError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "InstructionEntryValueTooLargeError";
+var isFormNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "FormNotFoundError";
+var isFormInvalidAnswerError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "FormInvalidAnswerError";
+var isFormAlreadySettledError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "FormAlreadySettledError";
+var isProviderNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "ProviderNotFoundError";
+var isIntegrationNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "IntegrationNotFoundError";
+var isIntegrationAttemptNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "IntegrationAttemptNotFoundError";
+var isIntegrationMethodNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "IntegrationMethodNotFoundError";
+var isMcpServerNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "McpServerNotFoundError";
+var isProjectNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "ProjectNotFoundError";
+var isPermissionNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "PermissionNotFoundError";
+var isFileNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "FileNotFoundError";
+var isRpcError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "RpcError";
+var isRpcInternalError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "RpcInternalError";
+var isPtyNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "PtyNotFoundError";
+var isForbiddenError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "ForbiddenError";
+var isShellNotFoundError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "ShellNotFoundError";
+var isWorktreeError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "WorktreeError";
+var isVcsInitNotSupportedError2 = (value) => typeof value === "object" && value !== null && ("_tag" in value) && value["_tag"] === "VcsInitNotSupportedError";
+
+export { isInvalidRequestError2, isUnauthorizedError2, isLocationNotFoundError2, isServiceUnavailableError2, isAgentNotFoundError2, isInvalidCursorError2, isSessionNotFoundError2, isConflictError2, isUnknownError2, isMessageNotFoundError2, isCommandNotFoundError2, isCommandExecutionError2, isSkillNotFoundError2, isSessionBusyError2, isInstructionEntryValueTooLargeError2, isFormNotFoundError2, isFormInvalidAnswerError2, isFormAlreadySettledError2, isProviderNotFoundError2, isIntegrationNotFoundError2, isIntegrationAttemptNotFoundError2, isIntegrationMethodNotFoundError2, isMcpServerNotFoundError2, isProjectNotFoundError2, isPermissionNotFoundError2, isFileNotFoundError2, isRpcError2, isRpcInternalError2, isPtyNotFoundError2, isForbiddenError2, isShellNotFoundError2, isWorktreeError2, isVcsInitNotSupportedError2 };

package/dist/harness-runtime/vendor/opencode-client/chunks/service-probe-wjyeq25y.js

@@ -0,0 +1,30 @@
+import {
+  make7
+} from "./service-probe-frbwqjmf.js";
+import {
+  make6
+} from "./service-probe-ecs5ftka.js";
+import {
+  makeRpc2
+} from "./service-probe-1y4a697q.js";
+import {
+  __export
+} from "./service-probe-9rqn6x4v.js";
+
+// src/promise/client.ts
+var exports_client3 = {};
+__export(exports_client3, {
+  OpenCode: () => exports_client3,
+  make: () => make5
+});
+function make5(options) {
+  const raw = make6(options);
+  const events = make7((signal, onActivity) => raw.event.subscribe({ signal, onActivity }));
+  return {
+    ...raw,
+    rpc: Object.assign(makeRpc2(raw, events), raw.rpc),
+    event: events
+  };
+}
+
+export { make5, exports_client3 };

package/dist/harness-runtime/vendor/opencode-client/chunks/service-probe-xgnj2w4v.js

@@ -0,0 +1,20 @@
+// src/service-timing.ts
+var timings = new WeakMap;
+var defaultEnsureTiming2 = {
+  pollInterval: 25,
+  requestTimeout: 2000,
+  spawnDelay: 5000,
+  maxSpawnDelay: 30000,
+  promiseTimeout: 120000,
+  stopPollInterval: 50,
+  stopPollAttempts: 100
+};
+function ensureTiming2(options) {
+  return timings.get(options) ?? defaultEnsureTiming2;
+}
+function withEnsureTiming2(options, overrides) {
+  timings.set(options, { ...defaultEnsureTiming2, ...overrides });
+  return options;
+}
+
+export { defaultEnsureTiming2, ensureTiming2, withEnsureTiming2 };

package/dist/harness-runtime/vendor/opencode-client/chunks/service-probe-y2etg5bs.js

@@ -0,0 +1,9 @@
+// src/effect/generated/client-error.ts
+import { Schema } from "effect";
+
+class ClientError2 extends Schema.TaggedError()("ClientError", {
+  cause: Schema.Defect()
+}) {
+}
+
+export { ClientError2 };

package/dist/harness-runtime/vendor/opencode-client/chunks/service-probe-ydhz1zrh.js

@@ -0,0 +1,238 @@
+// src/solid/connection.ts
+import { batch, onCleanup } from "solid-js";
+import { createStore } from "solid-js/store";
+var connectTimeout = 2000;
+var reconnectDelay = 1000;
+var connectionHistoryLimit = 50;
+var defaultIdleTimeout2 = 45000;
+var foregroundIdleThreshold2 = 20000;
+function createClientConnection2(initialApi, options) {
+  const abort = new AbortController;
+  const history = [];
+  const idleTimeout = options.idleTimeout ?? defaultIdleTimeout2;
+  const [connection, setConnection] = createStore({ status: "connecting", attempt: 0 });
+  let api = initialApi;
+  let pending = [];
+  let flushTimer;
+  let stream;
+  let current;
+  let run;
+  let started = false;
+  let generation = 0;
+  let lastActivity = 0;
+  let forced = false;
+  function record(status, attempt, error) {
+    history.push({ type: "client.connection", created: Date.now(), data: { status, attempt, error } });
+    if (history.length > connectionHistoryLimit)
+      history.shift();
+  }
+  function publish(event) {
+    pending.push(event);
+    if (flushTimer)
+      return;
+    flushTimer = setTimeout(() => {
+      flushTimer = undefined;
+      const events = pending;
+      pending = [];
+      batch(() => events.forEach(options.onEvent));
+    }, options.flushInterval ?? 10);
+  }
+  async function connect(signal, attempt) {
+    let connectedAt;
+    const request = new AbortController;
+    current = request;
+    const cancel = () => request.abort(signal.reason);
+    const timeout = setTimeout(() => request.abort(new Error("Timed out connecting to server")), connectTimeout);
+    signal.addEventListener("abort", cancel, { once: true });
+    let watchdog;
+    const touch = () => {
+      lastActivity = Date.now();
+      if (connectedAt === undefined)
+        return;
+      clearTimeout(watchdog);
+      watchdog = setTimeout(() => request.abort(new Error("Event stream stalled")), idleTimeout);
+    };
+    try {
+      record(attempt === 0 ? "connecting" : "reconnecting", attempt);
+      options.log?.info?.("event stream connecting", { attempt });
+      const iterator = api.event.subscribe({ signal: request.signal, onActivity: touch })[Symbol.asyncIterator]();
+      const first = await iterator.next();
+      if (signal.aborted)
+        return { error: undefined, connectedAt };
+      if (first.done)
+        return {
+          error: request.signal.reason instanceof Error ? request.signal.reason : new Error("Event stream disconnected"),
+          connectedAt
+        };
+      if (first.value.type !== "server.connected")
+        return { error: new Error("Event stream did not start with server.connected"), connectedAt };
+      clearTimeout(timeout);
+      record("connected", attempt);
+      connectedAt = Date.now();
+      touch();
+      options.log?.info?.("event stream connected");
+      publish(first.value);
+      setConnection({ status: "connected", attempt: 0, error: undefined });
+      while (!signal.aborted) {
+        const event = await iterator.next();
+        if (signal.aborted)
+          return { error: undefined, connectedAt };
+        if (event.done)
+          return {
+            error: request.signal.reason instanceof Error ? request.signal.reason : new Error("Event stream disconnected"),
+            connectedAt
+          };
+        touch();
+        if ("durable" in event.value && event.value.durable)
+          options.log?.debug?.("event", {
+            type: event.value.type,
+            aggregateID: event.value.durable.aggregateID,
+            seq: event.value.durable.seq
+          });
+        publish(event.value);
+      }
+      return { error: undefined, connectedAt };
+    } catch (error) {
+      return { error, connectedAt };
+    } finally {
+      request.abort();
+      if (current === request)
+        current = undefined;
+      clearTimeout(timeout);
+      clearTimeout(watchdog);
+      signal.removeEventListener("abort", cancel);
+    }
+  }
+  async function runStream(active) {
+    let attempt = 0;
+    while (!abort.signal.aborted && started && generation === active) {
+      setConnection({ status: attempt === 0 ? "connecting" : "reconnecting", attempt });
+      const controller = new AbortController;
+      stream = controller;
+      const cancel = () => controller.abort(abort.signal.reason);
+      abort.signal.addEventListener("abort", cancel);
+      const result = await connect(controller.signal, attempt);
+      abort.signal.removeEventListener("abort", cancel);
+      if (abort.signal.aborted || !started || generation !== active)
+        return;
+      if (result.connectedAt !== undefined && Date.now() - result.connectedAt >= reconnectDelay)
+        attempt = 0;
+      attempt += 1;
+      const message = errorMessage(result.error);
+      record("disconnected", attempt, message);
+      options.log?.info?.("event stream disconnected", { attempt, error: message });
+      setConnection({ status: "reconnecting", attempt, error: message });
+      if (options.reconnect) {
+        const next = await options.reconnect(controller.signal).catch((error) => {
+          if (!controller.signal.aborted)
+            options.log?.info?.("server resolution failed", { attempt, error: errorMessage(error) });
+        });
+        if (abort.signal.aborted || controller.signal.aborted || !started || generation !== active)
+          return;
+        if (next) {
+          api = next;
+          if (attempt === 1)
+            continue;
+        }
+      }
+      if (forced) {
+        forced = false;
+        continue;
+      }
+      await wait(reconnectDelay, controller.signal);
+    }
+  }
+  function start() {
+    if (started)
+      return run;
+    started = true;
+    forced = false;
+    const active = ++generation;
+    const previous = run;
+    const current = (async () => {
+      if (previous)
+        await previous;
+      await runStream(active);
+    })().finally(() => {
+      if (run !== current)
+        return;
+      run = undefined;
+    });
+    run = current;
+    return run;
+  }
+  function stop() {
+    if (!started)
+      return;
+    started = false;
+    generation += 1;
+    stream?.abort();
+    setConnection({ status: "connecting", attempt: 0, error: undefined });
+  }
+  function resync(reason) {
+    if (!started || connection.status !== "connected")
+      return;
+    options.log?.info?.("event stream resync", { reason, idle: Date.now() - lastActivity });
+    forced = true;
+    current?.abort(new Error(reason));
+  }
+  if (options.pageLifecycle) {
+    const pagehide = () => stop();
+    const pageshow = () => void start();
+    const visibility = () => {
+      if (document.visibilityState !== "visible")
+        return;
+      if (Date.now() - lastActivity < foregroundIdleThreshold2)
+        return;
+      resync("Page returned to the foreground after the event stream went quiet");
+    };
+    const online = () => resync("Network connection restored");
+    window.addEventListener("pagehide", pagehide);
+    window.addEventListener("pageshow", pageshow);
+    window.addEventListener("online", online);
+    document.addEventListener("visibilitychange", visibility);
+    onCleanup(() => {
+      window.removeEventListener("pagehide", pagehide);
+      window.removeEventListener("pageshow", pageshow);
+      window.removeEventListener("online", online);
+      document.removeEventListener("visibilitychange", visibility);
+    });
+  }
+  start();
+  onCleanup(() => {
+    stop();
+    abort.abort();
+    if (flushTimer)
+      clearTimeout(flushTimer);
+    pending = [];
+  });
+  return {
+    status: () => connection.status,
+    attempt: () => connection.attempt,
+    error: () => connection.error,
+    internal: {
+      history: () => history.slice(),
+      resync
+    }
+  };
+}
+function errorMessage(error) {
+  if (error === undefined)
+    return;
+  if (error instanceof Error)
+    return error.message;
+  return String(error);
+}
+function wait(delay, signal) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(done, delay);
+    signal.addEventListener("abort", done, { once: true });
+    function done() {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve();
+    }
+  });
+}
+
+export { defaultIdleTimeout2, foregroundIdleThreshold2, createClientConnection2 };

package/dist/harness-runtime/vendor/opencode-client/chunks/service-probe-z6qdwcsf.js

@@ -0,0 +1,62 @@
+import {
+  read2,
+  readError2,
+  event2,
+  eventType2
+} from "./service-probe-t1xa31vm.js";
+import {
+  __export
+} from "./service-probe-9rqn6x4v.js";
+
+// src/effect/rpc.ts
+var exports_rpc = {};
+__export(exports_rpc, {
+  RpcClientRuntime: () => exports_rpc,
+  aborted: () => aborted2,
+  make: () => make4
+});
+import { Effect, Stream } from "effect";
+function make4(call, subscribe) {
+  return (definition) => {
+    const methods = Object.fromEntries(Object.entries(definition.methods).map(([name, method]) => [
+      name,
+      (input, options) => {
+        const result = Effect.gen(function* () {
+          const response = yield* call({
+            rpcID: definition.id,
+            method: name,
+            input,
+            location: options?.location
+          }, options);
+          return yield* read2(method.output, response.output);
+        }).pipe(Effect.catch((error) => readError2(method, error)));
+        const signal = options?.signal;
+        if (!signal)
+          return result;
+        return Effect.suspend(() => signal.aborted ? Effect.interrupt : Effect.raceFirst(result, Effect.andThen(aborted2(signal), Effect.interrupt)));
+      }
+    ]));
+    return Object.assign(methods, {
+      events: {
+        subscribe: (name) => {
+          const type = eventType2(definition, name);
+          if (!Object.hasOwn(definition.events, name))
+            return Stream.fail(new Error(`Unknown RPC event: ${type}`));
+          const schema = definition.events[name];
+          return subscribe().pipe(Stream.filter((event) => event.type === type), Stream.mapEffect((event) => event2(definition, name, schema, event)));
+        }
+      }
+    });
+  };
+}
+function aborted2(signal) {
+  return Effect.callback((resume) => {
+    if (signal.aborted)
+      return resume(Effect.void);
+    const abort = () => resume(Effect.void);
+    signal.addEventListener("abort", abort, { once: true });
+    return Effect.sync(() => signal.removeEventListener("abort", abort));
+  });
+}
+
+export { make4, aborted2, exports_rpc };

package/dist/harness-runtime/vendor/opencode-client/contract.d.ts

@@ -0,0 +1 @@
+export { ClientApi, effectOmitEndpoints, groupNames, promiseOmitEndpoints } from "@opencode/protocol/client";

package/dist/harness-runtime/vendor/opencode-client/contract.js

@@ -0,0 +1,12 @@
+import {
+  ClientApi2,
+  effectOmitEndpoints2,
+  groupNames2,
+  promiseOmitEndpoints2
+} from "./chunks/service-probe-vmytr4q8.js";
+export {
+  ClientApi2 as ClientApi,
+  effectOmitEndpoints2 as effectOmitEndpoints,
+  groupNames2 as groupNames,
+  promiseOmitEndpoints2 as promiseOmitEndpoints
+};