@graphrefly/graphrefly 0.45.0 → 0.46.0

package/dist/utils/ai/node.cjs

@@ -0,0 +1,648 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/ai/node.ts
+var node_exports = {};
+__export(node_exports, {
+  fallbackAdapter: () => fallbackAdapter2
+});
+module.exports = __toCommonJS(node_exports);
+
+// src/utils/ai/adapters/providers/fallback-node.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node = require("@graphrefly/pure-ts/extra/node");
+
+// src/utils/ai/adapters/providers/fallback.ts
+var import_core6 = require("@graphrefly/pure-ts/core");
+var import_extra5 = require("@graphrefly/pure-ts/extra");
+
+// src/utils/ai/adapters/middleware/replay-cache.ts
+var import_core4 = require("@graphrefly/pure-ts/core");
+var import_extra4 = require("@graphrefly/pure-ts/extra");
+
+// src/base/composition/single-from-any.ts
+var import_core2 = require("@graphrefly/pure-ts/core");
+var import_extra = require("@graphrefly/pure-ts/extra");
+
+// src/base/sources/settled.ts
+var import_core = require("@graphrefly/pure-ts/core");
+function firstValueFrom(source) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let shouldUnsub = false;
+    let unsub;
+    unsub = source.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (settled) return;
+        if (m[0] === import_core.DATA) {
+          settled = true;
+          resolve(m[1]);
+          if (unsub) {
+            unsub();
+            unsub = void 0;
+          } else shouldUnsub = true;
+          return;
+        }
+        if (m[0] === import_core.ERROR) {
+          settled = true;
+          reject(m[1]);
+          if (unsub) {
+            unsub();
+            unsub = void 0;
+          } else shouldUnsub = true;
+          return;
+        }
+        if (m[0] === import_core.COMPLETE) {
+          settled = true;
+          reject(new Error("completed without DATA"));
+          if (unsub) {
+            unsub();
+            unsub = void 0;
+          } else shouldUnsub = true;
+          return;
+        }
+      }
+    });
+    if (shouldUnsub) {
+      unsub?.();
+      unsub = void 0;
+    }
+  });
+}
+
+// src/base/composition/single-from-any.ts
+function singleFromAny(factory, opts = {}) {
+  const keyFn = opts.keyFn ?? ((k) => String(k));
+  const inFlight = /* @__PURE__ */ new Map();
+  return (key) => {
+    const k = keyFn(key);
+    const existing = inFlight.get(k);
+    if (existing) return existing;
+    const input = factory(key);
+    let rawPromise;
+    if (input != null && typeof input.then === "function") {
+      rawPromise = Promise.resolve(input);
+    } else if (input != null && typeof input === "object" && "subscribe" in input && "cache" in input) {
+      rawPromise = firstValueFrom(input);
+    } else if (input != null && typeof input === "object" && Symbol.asyncIterator in input) {
+      rawPromise = (async () => {
+        const iter = input[Symbol.asyncIterator]();
+        try {
+          const { value, done } = await iter.next();
+          if (done) throw new Error("singleFromAny: factory returned empty async iterable");
+          return value;
+        } finally {
+          await iter.return?.();
+        }
+      })();
+    } else if (input != null && typeof input === "object" && Symbol.iterator in input) {
+      rawPromise = (async () => {
+        const iter = input[Symbol.iterator]();
+        try {
+          const { value, done } = iter.next();
+          if (done) throw new Error("singleFromAny: factory returned empty iterable");
+          return value;
+        } finally {
+          iter.return?.();
+        }
+      })();
+    } else {
+      rawPromise = Promise.resolve(input);
+    }
+    let tracked;
+    const cleanup = () => {
+      if (inFlight.get(k) === tracked) inFlight.delete(k);
+    };
+    tracked = rawPromise.then(
+      (v) => {
+        cleanup();
+        return v;
+      },
+      (e) => {
+        cleanup();
+        throw e;
+      }
+    );
+    inFlight.set(k, tracked);
+    return tracked;
+  };
+}
+
+// src/utils/ai/adapters/_internal/content-addressed-cache.ts
+var import_extra2 = require("@graphrefly/pure-ts/extra");
+function contentAddressedCache(opts) {
+  const { storage, mode = "read-write", keyFn, keyPrefix = "llm-replay" } = opts;
+  const substrateMode = mode === "read-strict" ? "read" : mode;
+  const substrate = (0, import_extra2.contentAddressedStorage)({
+    storage,
+    keyPrefix,
+    mode: substrateMode,
+    keyContext: ({ messages, opts: invokeOpts }) => {
+      const { signal: _signal, keyContext: _keyContext, ...rest } = invokeOpts ?? {};
+      return { messages, opts: rest };
+    }
+  });
+  async function keyFor(messages, invokeOpts) {
+    if (keyFn) {
+      if (keyFn.length <= 1) {
+        const ctx = {
+          messages,
+          opts: invokeOpts,
+          context: invokeOpts?.keyContext
+        };
+        const raw2 = await keyFn(ctx);
+        return `${keyPrefix}:${raw2}`;
+      }
+      const raw = await keyFn(messages, invokeOpts);
+      return `${keyPrefix}:${raw}`;
+    }
+    return substrate.keyFor({ messages, opts: invokeOpts });
+  }
+  return {
+    keyFor,
+    async lookup(messages, invokeOpts) {
+      if (mode === "write") return void 0;
+      if (keyFn) {
+        const key = await keyFor(messages, invokeOpts);
+        const raw = await storage.load(key);
+        if (raw === void 0) return void 0;
+        return raw;
+      }
+      return substrate.lookup({ messages, opts: invokeOpts });
+    },
+    async store(messages, invokeOpts, value) {
+      if (mode === "read") return;
+      if (keyFn) {
+        const key = await keyFor(messages, invokeOpts);
+        await storage.save(key, value);
+        return;
+      }
+      await substrate.store({ messages, opts: invokeOpts }, value);
+    },
+    async forget(messages, invokeOpts) {
+      if (mode === "read" || mode === "write") return;
+      if (!storage.delete) return;
+      if (keyFn) {
+        const key = await keyFor(messages, invokeOpts);
+        await storage.delete(key);
+        return;
+      }
+      await substrate.forget({ messages, opts: invokeOpts });
+    }
+  };
+}
+
+// src/utils/ai/adapters/_internal/wrappers.ts
+var import_core3 = require("@graphrefly/pure-ts/core");
+var import_extra3 = require("@graphrefly/pure-ts/extra");
+function adapterWrapper(inner, impl, override) {
+  return {
+    provider: override?.provider ?? inner.provider,
+    model: override?.model ?? inner.model,
+    capabilities: override?.capabilities ?? inner.capabilities?.bind(inner),
+    invoke: impl.invoke,
+    stream: impl.stream
+  };
+}
+var MIDDLEWARE_LAYERS = /* @__PURE__ */ Symbol.for("graphrefly.adapter.middlewareLayers");
+function withLayer(adapter, layerName, inner) {
+  const innerLayers = inner ? readLayers(inner) : [];
+  const chain = [...innerLayers, layerName];
+  Object.defineProperty(adapter, MIDDLEWARE_LAYERS, {
+    value: Object.freeze(chain),
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+  return adapter;
+}
+function readLayers(adapter) {
+  const v = adapter[MIDDLEWARE_LAYERS];
+  return Array.isArray(v) ? v : [];
+}
+
+// src/utils/ai/adapters/middleware/replay-cache.ts
+var ReplayCacheMissError = class extends Error {
+  constructor(key, method) {
+    super(`withReplayCache: no cached response for ${method} (key=${key}, mode=read-strict)`);
+    this.key = key;
+    this.method = method;
+  }
+  name = "ReplayCacheMissError";
+};
+function withReplayCache(inner, opts) {
+  const mode = opts.mode ?? "read-write";
+  const cacheStreaming = opts.cacheStreaming ?? false;
+  const captureStreamCadence = opts.captureStreamCadence ?? false;
+  const replaySpeed = opts.replaySpeed ?? 1;
+  const keyPrefix = opts.keyPrefix ?? "llm-replay";
+  const isReadOnly = mode === "read" || mode === "read-strict";
+  const cache = contentAddressedCache({
+    storage: opts.storage,
+    mode: mode === "write-only" ? "write" : mode,
+    keyFn: opts.keyFn,
+    keyPrefix
+  });
+  const sleepMs = (ms) => ms <= 0 ? Promise.resolve() : new Promise((resolve) => {
+    const t = new import_core4.ResettableTimer();
+    t.start(ms, () => resolve());
+  });
+  const upstreamInFlight = singleFromAny(
+    async ({ messages, invokeOpts }) => {
+      return await firstValueFrom((0, import_extra4.fromAny)(inner.invoke(messages, invokeOpts)));
+    },
+    { keyFn: ({ _precomputedKey }) => _precomputedKey }
+  );
+  const wrap = adapterWrapper(inner, {
+    async invoke(messages, invokeOpts) {
+      const key = await cache.keyFor(messages, invokeOpts);
+      const entry = await cache.lookup(messages, invokeOpts);
+      if (entry?.response) {
+        const cached = entry.response;
+        return { ...cached, metadata: { ...cached.metadata ?? {}, replayCache: "hit" } };
+      }
+      if (mode === "read-strict") throw new ReplayCacheMissError(key, "invoke");
+      const resp = await upstreamInFlight({ messages, invokeOpts, _precomputedKey: key });
+      if (!isReadOnly) {
+        await cache.store(messages, invokeOpts, { response: resp, storedAtNs: (0, import_core4.wallClockNs)() });
+      }
+      return resp;
+    },
+    async *stream(messages, invokeOpts) {
+      if (!cacheStreaming) {
+        for await (const delta of inner.stream(messages, invokeOpts)) yield delta;
+        return;
+      }
+      const key = await cache.keyFor(messages, invokeOpts);
+      const entry = await cache.lookup(messages, invokeOpts);
+      if (entry) {
+        const cached = entry.response;
+        if (entry.streamChunks && entry.streamCadenceMs) {
+          for (let i = 0; i < entry.streamChunks.length; i++) {
+            const delay = entry.streamCadenceMs[i] ?? 0;
+            const effective = replaySpeed > 0 ? delay / replaySpeed : 0;
+            if (effective > 0) await sleepMs(effective);
+            yield { type: "token", delta: entry.streamChunks[i]?.delta ?? "" };
+          }
+        } else if (cached.content) {
+          yield { type: "token", delta: cached.content };
+        }
+        if (cached.usage) yield { type: "usage", usage: cached.usage };
+        yield { type: "finish", reason: cached.finishReason ?? "stop" };
+        return;
+      }
+      if (mode === "read-strict") throw new ReplayCacheMissError(key, "stream");
+      let content = "";
+      let usage;
+      let finishReason;
+      const chunks = [];
+      const delaysMs = [];
+      let lastNs;
+      for await (const delta of inner.stream(messages, invokeOpts)) {
+        if (delta.type === "token") {
+          content += delta.delta;
+          if (captureStreamCadence) {
+            const now = (0, import_core4.monotonicNs)();
+            const gap = lastNs === void 0 ? 0 : (now - lastNs) / 1e6;
+            delaysMs.push(gap);
+            lastNs = now;
+            chunks.push({ delta: delta.delta });
+          }
+        }
+        if (delta.type === "usage") usage = delta.usage;
+        if (delta.type === "finish") finishReason = delta.reason;
+        yield delta;
+      }
+      if ((content || usage) && !isReadOnly) {
+        const resp = {
+          content,
+          usage: usage ?? { input: { regular: 0 }, output: { regular: 0 } },
+          finishReason,
+          model: inner.model ?? invokeOpts?.model ?? "",
+          provider: inner.provider
+        };
+        const entryToStore = {
+          response: resp,
+          storedAtNs: (0, import_core4.wallClockNs)(),
+          ...captureStreamCadence ? { streamChunks: chunks, streamCadenceMs: delaysMs } : {}
+        };
+        await cache.store(messages, invokeOpts, entryToStore);
+      }
+    }
+  });
+  withLayer(wrap, "withReplayCache", inner);
+  return wrap;
+}
+
+// src/utils/ai/adapters/providers/dry-run.ts
+var import_core5 = require("@graphrefly/pure-ts/core");
+function makeAbortError() {
+  const err = new Error("aborted");
+  err.name = "AbortError";
+  return err;
+}
+function sleep(ms, signal) {
+  if (ms <= 0) return Promise.resolve();
+  if (signal?.aborted) return Promise.reject(makeAbortError());
+  return new Promise((resolve, reject) => {
+    const timer = new import_core5.ResettableTimer();
+    let onAbort;
+    const cleanup = () => {
+      timer.cancel();
+      if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+    };
+    timer.start(ms, () => {
+      cleanup();
+      resolve();
+    });
+    if (signal) {
+      onAbort = () => {
+        cleanup();
+        reject(makeAbortError());
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+function dryRunAdapter(opts = {}) {
+  const provider = opts.provider ?? "dry-run";
+  const model = opts.model ?? "dry-run-v1";
+  const latencyMs = opts.latencyMs ?? 0;
+  const streamChunkSize = Math.max(1, opts.streamChunkSize ?? 16);
+  const respondFn = opts.respond ?? ((msgs) => {
+    const lastUser = [...msgs].reverse().find((m) => m.role === "user");
+    return lastUser ? `echo: ${lastUser.content}` : "dry-run: no user message";
+  });
+  const usageFn = opts.usage ?? ((msgs, content) => {
+    const totalInput = msgs.reduce((s, m) => s + m.content.length, 0);
+    return {
+      input: { regular: Math.ceil(totalInput / 4) },
+      output: { regular: Math.ceil(content.length / 4) }
+    };
+  });
+  return {
+    provider,
+    model,
+    async invoke(messages, invokeOpts) {
+      await sleep(latencyMs, invokeOpts?.signal);
+      if (invokeOpts?.signal?.aborted) throw makeAbortError();
+      const content = respondFn(messages, invokeOpts);
+      const usage = usageFn(messages, content);
+      return {
+        content,
+        usage,
+        finishReason: "stop",
+        model: invokeOpts?.model ?? model,
+        provider,
+        tier: invokeOpts?.tier,
+        metadata: { dryRun: true }
+      };
+    },
+    async *stream(messages, invokeOpts) {
+      const content = respondFn(messages, invokeOpts);
+      const usage = usageFn(messages, content);
+      const chunkCount = Math.ceil(content.length / streamChunkSize) || 1;
+      const perChunkMs = latencyMs > 0 ? latencyMs / chunkCount : 0;
+      for (let i = 0; i < content.length; i += streamChunkSize) {
+        if (invokeOpts?.signal?.aborted) throw makeAbortError();
+        await sleep(perChunkMs, invokeOpts?.signal);
+        yield { type: "token", delta: content.slice(i, i + streamChunkSize) };
+      }
+      yield { type: "usage", usage };
+      yield { type: "finish", reason: "stop" };
+    }
+  };
+}
+
+// src/utils/ai/adapters/providers/fallback.ts
+function degradedResponse(provider, model) {
+  return {
+    content: "[fallback: no cached response available for this request]",
+    usage: { input: { regular: 0 }, output: { regular: 0 } },
+    finishReason: "stop",
+    model,
+    provider,
+    metadata: { degraded: true, reason: "no-fixture" }
+  };
+}
+function normalizeRespondResult(raw, provider, model) {
+  if (typeof raw === "string") {
+    return {
+      content: raw,
+      usage: { input: { regular: 0 }, output: { regular: 0 } },
+      finishReason: "stop",
+      model,
+      provider,
+      metadata: { degraded: true, reason: "respond" }
+    };
+  }
+  return raw;
+}
+async function fixtureKey(fixture, keyPrefix) {
+  if ("key" in fixture) return fixture.key;
+  const canonical = (0, import_extra5.canonicalJson)({ messages: fixture.messages, opts: fixture.invokeOpts ?? {} });
+  const hex = await (0, import_core6.sha256Hex)(canonical);
+  return `${keyPrefix}:${hex}`;
+}
+function toCachedEntry(fixture) {
+  const base = {
+    response: fixture.response,
+    // Real timestamp so future TTL-aware tiers don't treat inline fixtures
+    // as Epoch-old and evict them on first pass. Matches the wall-clock
+    // write `withReplayCache` uses for disk-written entries.
+    storedAtNs: (0, import_core6.wallClockNs)()
+  };
+  if ("key" in fixture && fixture.stream) {
+    const tokenChunks = fixture.stream.chunks.filter(
+      (c) => c.type === "token"
+    );
+    return {
+      ...base,
+      streamChunks: tokenChunks.map((c) => ({ delta: c.delta })),
+      streamCadenceMs: fixture.stream.delaysMs ?? tokenChunks.map(() => 0)
+    };
+  }
+  return base;
+}
+function resolveFixtureStorage(opts, keyPrefix) {
+  const sources = [];
+  if (opts.fixtures != null) sources.push("fixtures");
+  if (opts.fixturesStorage != null) sources.push("fixturesStorage");
+  if (sources.length > 1) {
+    throw new TypeError(
+      `fallbackAdapter: \`fixtures\` and \`fixturesStorage\` are mutually exclusive; got both ${sources.join(" and ")}. Pick one source. For filesystem directories use the node subpath's \`fallbackAdapter\`.`
+    );
+  }
+  if (opts.fixtures) {
+    const tier = (0, import_extra5.memoryKv)();
+    const fixtures = opts.fixtures;
+    const seedReady = (async () => {
+      for (const fixture of fixtures) {
+        const key = await fixtureKey(fixture, keyPrefix);
+        await tier.save(key, toCachedEntry(fixture));
+      }
+    })();
+    seedReady.catch(() => {
+    });
+    return { tier, seedReady };
+  }
+  if (opts.fixturesStorage) return { tier: opts.fixturesStorage, seedReady: Promise.resolve() };
+  return { tier: void 0, seedReady: Promise.resolve() };
+}
+function fallbackAdapter(opts = {}) {
+  const provider = opts.provider ?? "fallback";
+  const model = opts.model ?? "fallback";
+  const onMiss = opts.onMiss ?? "respond";
+  const keyPrefix = opts.keyPrefix ?? "fallback";
+  const leaf = (() => {
+    if (opts.record) return opts.record.adapter;
+    if (onMiss === "throw") {
+      return dryRunAdapter({
+        provider,
+        model,
+        respond: () => "[unreachable: read-strict mode throws on miss]"
+      });
+    }
+    return {
+      provider,
+      model,
+      async invoke(messages, invokeOpts) {
+        const raw = opts.respond ? opts.respond(messages, invokeOpts) : degradedResponse(provider, model);
+        return normalizeRespondResult(raw, provider, model);
+      },
+      async *stream(messages, invokeOpts) {
+        const raw = opts.respond ? opts.respond(messages, invokeOpts) : degradedResponse(provider, model);
+        const r = normalizeRespondResult(raw, provider, model);
+        yield { type: "token", delta: r.content };
+        if (r.usage) yield { type: "usage", usage: r.usage };
+        yield { type: "finish", reason: r.finishReason ?? "stop" };
+      }
+    };
+  })();
+  let storage;
+  let seedReady = Promise.resolve();
+  if (opts.record) {
+    if (!opts.record.storage) {
+      throw new TypeError(
+        "fallbackAdapter: `record.storage` is required in record mode. For filesystem `record.dir` convenience, use the node subpath's `fallbackAdapter`."
+      );
+    }
+    storage = opts.record.storage;
+  } else {
+    const resolved = resolveFixtureStorage(opts, keyPrefix);
+    storage = resolved.tier ?? (0, import_extra5.memoryKv)();
+    seedReady = resolved.seedReady;
+  }
+  const mode = opts.record ? "read-write" : onMiss === "throw" ? "read-strict" : "read";
+  const cached = withReplayCache(leaf, {
+    storage,
+    mode,
+    keyPrefix,
+    cacheStreaming: true,
+    captureStreamCadence: true,
+    replaySpeed: opts.replaySpeed,
+    ...opts.keyFn ? { keyFn: opts.keyFn } : {}
+  });
+  return {
+    provider,
+    model,
+    capabilities: cached.capabilities?.bind(cached),
+    async invoke(messages, invokeOpts) {
+      await seedReady;
+      return cached.invoke(messages, invokeOpts);
+    },
+    async *stream(messages, invokeOpts) {
+      await seedReady;
+      for await (const delta of cached.stream(messages, invokeOpts)) yield delta;
+    }
+  };
+}
+
+// src/utils/ai/adapters/providers/fallback-node.ts
+function validateDirShape(dir) {
+  if (!(0, import_node_fs.existsSync)(dir)) return;
+  const files = (0, import_node_fs.readdirSync)(dir).filter((f) => f.endsWith(".json"));
+  if (files.length === 0) return;
+  const sample = files[0];
+  const path = (0, import_node_path.join)(dir, sample);
+  let raw;
+  try {
+    raw = JSON.parse((0, import_node_fs.readFileSync)(path, "utf8"));
+  } catch (err) {
+    throw new TypeError(`fallbackAdapter: ${path} is not valid JSON (${err.message}).`);
+  }
+  const asObj = raw;
+  const looksLikeHandAuthored = asObj != null && "messages" in asObj;
+  const missingFields = asObj == null || typeof asObj.response?.content !== "string" || typeof asObj.storedAtNs !== "number";
+  if (looksLikeHandAuthored || missingFields) {
+    const hint = looksLikeHandAuthored ? "`messages` at the top level means this looks hand-authored. " : "";
+    throw new TypeError(
+      `fallbackAdapter: ${path} is not in cache-file format. ${hint}Expected \`{ response: { content, usage, ... }, storedAtNs, ... }\` (the shape \`withReplayCache\` and this adapter's \`record\` mode write). For hand-authored fixtures, use the inline \`fixtures: FallbackFixture[]\` option \u2014 the adapter hashes messages for you.`
+    );
+  }
+}
+function fallbackAdapter2(opts = {}) {
+  const keyPrefix = opts.keyPrefix ?? "fallback";
+  const sources = [];
+  if (opts.fixtures != null) sources.push("fixtures");
+  if (opts.fixturesDir != null) sources.push("fixturesDir");
+  if (opts.fixturesStorage != null) sources.push("fixturesStorage");
+  if (sources.length > 1) {
+    throw new TypeError(
+      `fallbackAdapter: \`fixtures\`, \`fixturesDir\`, and \`fixturesStorage\` are mutually exclusive; got both ${sources.join(" and ")}. Pick one source.`
+    );
+  }
+  let fixturesStorage = opts.fixturesStorage;
+  if (opts.fixturesDir != null) {
+    const namespaced = (0, import_node_path.join)(opts.fixturesDir, keyPrefix);
+    validateDirShape(namespaced);
+    fixturesStorage = (0, import_node.fileKv)(namespaced);
+  }
+  let record;
+  if (opts.record) {
+    if (opts.record.storage && opts.record.dir) {
+      throw new TypeError(
+        "fallbackAdapter: `record.storage` and `record.dir` are mutually exclusive; pick one."
+      );
+    }
+    if (opts.record.storage) {
+      record = { adapter: opts.record.adapter, storage: opts.record.storage };
+    } else {
+      const recordDir = opts.record.dir ?? opts.fixturesDir;
+      if (recordDir == null) {
+        throw new TypeError(
+          "fallbackAdapter: record mode requires either `record.dir`, `record.storage`, or an inherited `fixturesDir`."
+        );
+      }
+      record = {
+        adapter: opts.record.adapter,
+        storage: (0, import_node.fileKv)((0, import_node_path.join)(recordDir, keyPrefix))
+      };
+    }
+  }
+  const { fixturesDir: _omit, record: _recordOmit, ...restOpts } = opts;
+  const baseOpts = {
+    ...restOpts,
+    ...fixturesStorage ? { fixturesStorage } : {},
+    ...record ? { record } : {}
+  };
+  return fallbackAdapter(baseOpts);
+}
+//# sourceMappingURL=node.cjs.map