@kodycodes/cli 1.26.1 → 1.26.3

package/dist/chunk-XDCOWU5R.js

@@ -0,0 +1,696 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  unmockedRequestError
+} from "./chunk-XOPPGRUP.js";
+import {
+  StructuredCliError,
+  notImplementedInMock
+} from "./chunk-BPGY4IE7.js";
+import {
+  userCacheDir
+} from "./chunk-BISUL7CE.js";
+
+// src/mock/mock-server.ts
+import {
+  createServer
+} from "node:http";
+
+// src/mock/mock-supported.ts
+var mockOpenApiOperationIds = [
+  "search",
+  "metaGetCurrentUser",
+  "usageGet"
+];
+var mockCapabilityPaths = [
+  "kody.metaGetCurrentUser",
+  "kody.search",
+  "kody.execute",
+  "kody.usageGet",
+  // Local package scratch storage via capability hops used by packageStorage()
+  // bridging in the mock runtime (see mock-server call dispatch).
+  "kody.__mockPackageStorageGet",
+  "kody.__mockPackageStorageSet",
+  "kody.__mockPackageStorageDelete",
+  "kody.__mockPackageStorageList",
+  "kody.__mockPackageStorageSql",
+  // Published package-app-kit / packageStorage helpers may hop these names
+  // directly (same scratch store as the __mock* bridges above).
+  "kody.packageStorageGet",
+  "kody.packageStorageSet",
+  "kody.packageStorageDelete",
+  "kody.packageStorageList",
+  "kody.packageStorageSql",
+  // Credential client: fake metadata + handles only (never prod secrets).
+  "kody.credentialClientOpen",
+  "kody.credentialClientOpenAll",
+  "kody.credentialClientCheck",
+  "kody.credentialClientRefresh",
+  // OAuth / ambient outbound hops — intercepted by the Node MSW gateway on
+  // --target mock (see mock-fetch-gateway.ts). Listed here so CapabilityProxy
+  // session probes treat them as known; the mock HTTP server refuses with
+  // unmocked_request if a call somehow bypasses the bridge.
+  "kody.authenticatedFetch",
+  "kody.gatewayFetch",
+  "kody.gatewayFetchStream",
+  // Read-only admin fixture so gift-cliff-ops-style packages can smoke locally.
+  "kody.adminUserList"
+];
+function isMockCapabilityPath(pathKey) {
+  return mockCapabilityPaths.includes(pathKey);
+}
+
+// src/mock/mock-storage.ts
+import { mkdirSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+var mockStateFile = "state.json";
+function mockSessionRoot(sessionId, env = process.env) {
+  return join(userCacheDir(env), "mock-sessions", sessionId);
+}
+function defaultMockSessionId(env = process.env) {
+  return env.KODY_MOCK_SESSION_ID?.trim() || "default";
+}
+async function loadMockSession(input) {
+  const env = input.env ?? process.env;
+  const sessionId = input.sessionId ?? defaultMockSessionId(env);
+  const root = mockSessionRoot(sessionId, env);
+  if (input.reset) {
+    await rm(root, { recursive: true, force: true });
+  }
+  await mkdir(root, { recursive: true });
+  const path = join(root, mockStateFile);
+  try {
+    const raw = JSON.parse(await readFile(path, "utf8"));
+    if (raw?.version === 1 && raw.sessionId === sessionId) {
+      return normalizeMockSessionCredentials(raw);
+    }
+  } catch {
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const fresh = {
+    version: 1,
+    sessionId,
+    createdAt: now,
+    updatedAt: now,
+    packageStorage: {},
+    credentials: {
+      MOCK_SECRET: {
+        id: "cred_mock_secret",
+        name: "MOCK_SECRET",
+        kind: "secret",
+        hosts: ["example.com"],
+        scope: "personal",
+        mockValue: "mock-secret-value"
+      }
+    },
+    searchCatalog: [
+      {
+        type: "guide",
+        id: "local_execute",
+        title: "Local CLI execute",
+        description: "Prefer @kodycodes/cli execute --local when Node \u226522."
+      },
+      {
+        type: "capability",
+        id: "metaGetCurrentUser",
+        title: "metaGetCurrentUser",
+        description: "Return the current authenticated user and org binding."
+      },
+      {
+        type: "guide",
+        id: "package_apps",
+        title: "Package apps",
+        description: "Hosted Worker apps on *.kody.run; use kody dev for local."
+      }
+    ]
+  };
+  await persistMockSession(fresh, env);
+  return fresh;
+}
+async function persistMockSession(state, env = process.env) {
+  state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const root = mockSessionRoot(state.sessionId, env);
+  await mkdir(root, { recursive: true });
+  await writeFile(join(root, mockStateFile), `${JSON.stringify(state, null, 2)}
+`);
+}
+function normalizeMockSessionCredentials(state) {
+  const credentials = {};
+  for (const [key, cred] of Object.entries(state.credentials ?? {})) {
+    credentials[key] = {
+      ...cred,
+      hosts: Array.isArray(cred.hosts) && cred.hosts.length > 0 ? cred.hosts : ["example.com"],
+      scope: cred.scope === "org" ? "org" : "personal"
+    };
+  }
+  if (!credentials.MOCK_SECRET) {
+    credentials.MOCK_SECRET = {
+      id: "cred_mock_secret",
+      name: "MOCK_SECRET",
+      kind: "secret",
+      hosts: ["example.com"],
+      scope: "personal",
+      mockValue: "mock-secret-value"
+    };
+  }
+  state.credentials = credentials;
+  return state;
+}
+function packageStorageGet(state, packageId, key) {
+  return state.packageStorage[packageId]?.rows[key];
+}
+function packageStorageSet(state, packageId, key, value) {
+  const bucket = state.packageStorage[packageId] ??= { rows: {} };
+  bucket.rows[key] = value;
+}
+function packageStorageDelete(state, packageId, key) {
+  const bucket = state.packageStorage[packageId];
+  if (!bucket || !(key in bucket.rows)) return false;
+  delete bucket.rows[key];
+  return true;
+}
+function packageStorageList(state, packageId) {
+  const rows = state.packageStorage[packageId]?.rows ?? {};
+  return Object.entries(rows).map(([key, value]) => ({ key, value }));
+}
+var openSqlDbs = /* @__PURE__ */ new Map();
+function packageSqlDbPath(state, packageId, env = process.env) {
+  const safe = packageId.replace(/[^a-zA-Z0-9._-]+/g, "_");
+  const dir = join(mockSessionRoot(state.sessionId, env), "sqlite");
+  mkdirSync(dir, { recursive: true });
+  return join(dir, `${safe || "package"}.sqlite`);
+}
+function openPackageSqlDb(state, packageId, env = process.env) {
+  const path = packageSqlDbPath(state, packageId, env);
+  const cacheKey = `${state.sessionId}:${path}`;
+  const existing = openSqlDbs.get(cacheKey);
+  if (existing) return existing;
+  const db = new DatabaseSync(path);
+  openSqlDbs.set(cacheKey, db);
+  return db;
+}
+function closePackageSqlDbsForSession(sessionId) {
+  for (const [key, db] of openSqlDbs) {
+    if (!key.startsWith(`${sessionId}:`)) continue;
+    try {
+      db.close();
+    } catch {
+    }
+    openSqlDbs.delete(key);
+  }
+}
+function packageStorageSql(state, packageId, query, bindings = [], env = process.env) {
+  const db = openPackageSqlDb(state, packageId, env);
+  const stmt = db.prepare(query);
+  const params = bindings.map((value) => {
+    if (value === null) return null;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") {
+      return value;
+    }
+    if (typeof value === "boolean") return value ? 1 : 0;
+    if (value instanceof Uint8Array) return value;
+    return String(value);
+  });
+  const trimmed = query.trimStart().toLowerCase();
+  const isQuery = trimmed.startsWith("select") || trimmed.startsWith("with") || trimmed.startsWith("pragma") || trimmed.startsWith("explain");
+  if (isQuery) {
+    const rows = stmt.all(...params);
+    return { rows };
+  }
+  const info = stmt.run(...params);
+  return { rows: [], changes: typeof info.changes === "number" ? info.changes : 0 };
+}
+
+// src/mock/mock-server.ts
+var mockTokenPrefix = "kody_mock_";
+function isMockApiToken(token) {
+  return token.startsWith(mockTokenPrefix) || token === "mock";
+}
+function mintMockApiToken(sessionId) {
+  return `${mockTokenPrefix}${sessionId}`;
+}
+async function startMockServer(options = {}) {
+  const sessionIdForClose = options.sessionId?.trim() || defaultMockSessionId(options.env ?? process.env);
+  if (options.resetStorage) {
+    closePackageSqlDbsForSession(sessionIdForClose);
+  }
+  let state = await loadMockSession({
+    sessionId: options.sessionId,
+    env: options.env,
+    reset: options.resetStorage
+  });
+  const packageId = options.packageId ?? `local-${state.sessionId}`;
+  const orgSlug = options.orgSlug?.trim() || "mock-org";
+  const env = options.env;
+  const server = createServer((req, res) => {
+    void handleRequest(req, res, {
+      getState: () => state,
+      setState: async (next) => {
+        state = next;
+        await persistMockSession(state, env);
+      },
+      packageId,
+      orgSlug,
+      env
+    });
+  });
+  const host = options.host ?? "127.0.0.1";
+  const port = options.port ?? 0;
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, () => resolve());
+  });
+  const address = server.address();
+  const url = `http://${host}:${address.port}`;
+  return {
+    url,
+    port: address.port,
+    sessionId: state.sessionId,
+    state: () => state,
+    close: () => new Promise((resolve, reject) => {
+      server.close((error) => error ? reject(error) : resolve());
+    })
+  };
+}
+async function ensureMockTarget(input) {
+  if (input.existing) {
+    return {
+      apiUrl: input.existing.url,
+      token: mintMockApiToken(input.existing.sessionId),
+      server: input.existing,
+      started: false
+    };
+  }
+  const server = await startMockServer({
+    sessionId: input.sessionId,
+    resetStorage: input.resetStorage,
+    packageId: input.packageId,
+    orgSlug: input.orgSlug,
+    env: input.env
+  });
+  return {
+    apiUrl: server.url,
+    token: mintMockApiToken(server.sessionId),
+    server,
+    started: true
+  };
+}
+async function handleRequest(req, res, ctx) {
+  try {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    const method = (req.method ?? "GET").toUpperCase();
+    const body = await readJsonBody(req);
+    const requestOrg = url.searchParams.get("org")?.trim() || void 0;
+    const effectiveOrg = requestOrg || ctx.orgSlug;
+    const callCtx = { ...ctx, orgSlug: effectiveOrg };
+    if (method === "GET" && url.pathname === "/openapi.json") {
+      return sendJson(res, 200, mockOpenApiDocument());
+    }
+    if (method === "GET" && url.pathname === "/v1/capability-proxy/session") {
+      assertMockAuth(req);
+      return sendJson(res, 200, {
+        scopes: ["org:execute", "org:read", "package:execute", "package:read", "search:read"],
+        features: ["local-execute", "credential-call-map"],
+        expiresAt: new Date(Date.now() + 864e5).toISOString()
+      });
+    }
+    if (method === "POST" && url.pathname === "/v1/capability-proxy/call") {
+      assertMockAuth(req);
+      const path = Array.isArray(body?.path) ? body.path : null;
+      const args = Array.isArray(body?.args) ? body.args : [];
+      if (!path || path.length === 0) {
+        return sendJson(res, 400, {
+          error: { code: "invalid_request", message: "path is required" }
+        });
+      }
+      const pathKey = path.join(".");
+      if (!isMockCapabilityPath(pathKey)) {
+        const err2 = notImplementedInMock({ operation: `CapabilityProxy ${pathKey}` });
+        return sendJson(res, 501, { error: err2.toJSON() });
+      }
+      try {
+        const result = await dispatchCapabilityCall(pathKey, args, callCtx);
+        return sendJson(res, 200, { result });
+      } catch (error) {
+        if (error instanceof StructuredCliError) {
+          const status = error.code === "unmocked_request" ? 400 : 501;
+          return sendJson(res, status, { error: error.toJSON() });
+        }
+        throw error;
+      }
+    }
+    if (method === "POST" && url.pathname === "/v1/local-execute/package-graph") {
+      assertMockAuth(req);
+      return sendJson(res, 200, {
+        modules: [],
+        compatibilityDate: "2026-04-16",
+        compatibilityFlags: ["nodejs_compat"]
+      });
+    }
+    if (method === "GET" && url.pathname === "/v1/search") {
+      assertMockAuth(req);
+      const query = url.searchParams.get("query") ?? "";
+      const entity = url.searchParams.get("entity") ?? void 0;
+      return sendJson(res, 200, mockSearch(callCtx.getState(), { query, entity }));
+    }
+    if (method === "GET" && url.pathname === "/v1/me") {
+      assertMockAuth(req);
+      return sendJson(res, 200, mockCurrentUser(callCtx.getState(), callCtx.orgSlug));
+    }
+    if (url.pathname.startsWith("/v1/")) {
+      const err2 = notImplementedInMock({
+        operation: `${method} ${url.pathname}`
+      });
+      return sendJson(res, 501, { error: err2.toJSON() });
+    }
+    const err = notImplementedInMock({ operation: `${method} ${url.pathname}` });
+    return sendJson(res, 501, { error: err.toJSON() });
+  } catch (error) {
+    if (error instanceof AuthError) {
+      return sendJson(res, 401, {
+        error: { code: "unauthorized", message: error.message }
+      });
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return sendJson(res, 500, {
+      error: { code: "mock_internal_error", message }
+    });
+  }
+}
+var AuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AuthError";
+  }
+};
+function assertMockAuth(req) {
+  const header = req.headers.authorization;
+  if (typeof header !== "string" || !header.toLowerCase().startsWith("bearer ")) {
+    throw new AuthError("Mock API requires Authorization: Bearer <token>.");
+  }
+  const token = header.slice("bearer ".length).trim();
+  if (!isMockApiToken(token) && !token.startsWith("kody_at_") && token.length > 0) {
+    return;
+  }
+  if (!token) throw new AuthError("Mock API bearer token is empty.");
+}
+async function dispatchCapabilityCall(pathKey, args, ctx) {
+  const state = ctx.getState();
+  switch (pathKey) {
+    case "kody.metaGetCurrentUser":
+      return mockCurrentUser(state, ctx.orgSlug);
+    case "kody.search": {
+      const params = args[0] ?? {};
+      return mockSearch(state, params);
+    }
+    case "kody.usageGet":
+      return {
+        period: "mock",
+        credits: { used: 0, limit: null },
+        note: "Mock usage \u2014 not real entitlement data."
+      };
+    case "kody.execute": {
+      const params = args[0] ?? {};
+      throw notImplementedInMock({
+        operation: "kody.execute (cloud sandbox)",
+        fix: "Use `kody execute --local --target mock` so the module runs in local workerd against this mock."
+      });
+    }
+    case "kody.__mockPackageStorageGet":
+    case "kody.packageStorageGet": {
+      const key = String(args[0]?.key ?? "");
+      return { value: packageStorageGet(state, ctx.packageId, key) ?? null };
+    }
+    case "kody.__mockPackageStorageSet":
+    case "kody.packageStorageSet": {
+      const input = args[0];
+      packageStorageSet(state, ctx.packageId, String(input?.key ?? ""), input?.value);
+      await ctx.setState(state);
+      return { ok: true };
+    }
+    case "kody.__mockPackageStorageDelete":
+    case "kody.packageStorageDelete": {
+      const key = String(args[0]?.key ?? "");
+      const deleted = packageStorageDelete(state, ctx.packageId, key);
+      await ctx.setState(state);
+      return { deleted };
+    }
+    case "kody.__mockPackageStorageList":
+    case "kody.packageStorageList": {
+      return { entries: packageStorageList(state, ctx.packageId) };
+    }
+    case "kody.__mockPackageStorageSql":
+    case "kody.packageStorageSql": {
+      const input = args[0] ?? {};
+      const query = String(input.query ?? "");
+      if (!query.trim()) {
+        throw new Error("packageStorage().sql requires a non-empty query string.");
+      }
+      return packageStorageSql(
+        state,
+        ctx.packageId,
+        query,
+        Array.isArray(input.bindings) ? input.bindings : [],
+        ctx.env
+      );
+    }
+    case "kody.credentialClientOpen": {
+      const input = args[0] ?? {};
+      const key = String(input.key ?? input.name ?? args[0] ?? "").trim();
+      const opened = openMockCredential(state, key);
+      return { ok: true, value: opened };
+    }
+    case "kody.credentialClientOpenAll": {
+      const key = String(args[0]?.key ?? "").trim();
+      const matches = Object.values(state.credentials).filter(
+        (cred) => !key || cred.name === key || cred.name.toUpperCase() === key.toUpperCase() || cred.id === key
+      );
+      if (key && matches.length === 0) {
+        return { ok: true, value: [] };
+      }
+      const opened = (key ? matches : Object.values(state.credentials)).map(
+        (cred) => mockOpenedCredential(cred)
+      );
+      return { ok: true, value: opened };
+    }
+    case "kody.credentialClientCheck":
+      return { ok: true, value: { warnings: [], checked: args[0] ?? null, strict: false } };
+    case "kody.credentialClientRefresh":
+      return { ok: true, value: { refreshed: false, mock: true } };
+    case "kody.authenticatedFetch":
+    case "kody.gatewayFetch":
+    case "kody.gatewayFetchStream": {
+      const request = args[0] ?? {};
+      const nested = request.request ?? request;
+      const method = String(nested.method ?? "GET").toUpperCase();
+      const url = String(nested.url ?? "");
+      if (url) throw unmockedRequestError(method, url);
+      throw new StructuredCliError({
+        code: "unmocked_request",
+        message: `Unmocked ${pathKey} under --target mock (missing request.url).`,
+        target: "mock",
+        where: pathKey,
+        fix: "Pass request.url, or add handlers in .kody/mocks.ts. createAuthenticatedFetch, credential().fetch, gatewayFetch, and gatewayFetchStream go through the same MSW gateway.",
+        details: { mocksPath: ".kody/mocks.ts" }
+      });
+    }
+    case "kody.adminUserList": {
+      const params = args[0] ?? {};
+      const page = typeof params.page === "number" ? params.page : 1;
+      const pageSize = typeof params.pageSize === "number" ? params.pageSize : typeof params.limit === "number" ? params.limit : 20;
+      return {
+        total: 1,
+        page,
+        pageSize,
+        users: [
+          {
+            stableUserId: "user_mock",
+            username: "mock-user",
+            email: "mock@example.com",
+            email_verified: true,
+            email_verified_at: "2026-01-01T00:00:00.000Z",
+            plan: "free",
+            manualPlan: "free",
+            stripePlan: null,
+            effectivePlan: "free",
+            secondAgentGiftExpiresAt: null,
+            referralCreditExpiresAt: null,
+            overlayExpiresAt: null,
+            isProOverlay: false,
+            overlayType: null,
+            entitlementLadder: "public",
+            stripeCustomerLinked: false,
+            suspended_at: null,
+            email_outbound_paused_at: null,
+            email_verification_delivery: null,
+            email_verification_delivery_detail: null,
+            utm_source: null,
+            utm_medium: null,
+            utm_campaign: null,
+            utm_content: null,
+            utm_term: null,
+            first_touch_landing_path: null,
+            first_touch_referrer: null,
+            first_mcp_connected_at: null,
+            first_execute_at: null,
+            first_search_at: null,
+            first_saved_package_at: null,
+            mcp_client_name: null,
+            last_active_at: null,
+            created_at: "2026-01-01T00:00:00.000Z",
+            updated_at: "2026-01-01T00:00:00.000Z",
+            roles: ["user"]
+          }
+        ]
+      };
+    }
+    default: {
+      const exhaustive = pathKey;
+      throw notImplementedInMock({ operation: String(exhaustive) });
+    }
+  }
+}
+function openMockCredential(state, key) {
+  const cred = state.credentials[key] ?? state.credentials[key.toUpperCase()] ?? Object.values(state.credentials).find(
+    (entry) => entry.name === key || entry.name.toUpperCase() === key.toUpperCase()
+  );
+  if (!cred) {
+    throw new StructuredCliError({
+      code: "missing_secret",
+      message: `Mock credential ${JSON.stringify(key)} is not defined for this session.`,
+      target: "mock",
+      fix: "Add a fake credential to the mock session state or use --target prod with a real allow-listed secret.",
+      details: { key }
+    });
+  }
+  return mockOpenedCredential(cred);
+}
+function mockOpenedCredential(cred) {
+  return {
+    handle: `mock-handle:${cred.id}`,
+    key: cred.name,
+    name: cred.name,
+    scope: cred.scope ?? "personal",
+    kind: cred.kind,
+    hosts: [...cred.hosts?.length ? cred.hosts : ["example.com"]],
+    hint: "mock",
+    // Never expose a real secret; mockValue stays session-local scratch only.
+    metadata: { mock: true }
+  };
+}
+function mockCurrentUser(state, orgSlug) {
+  return {
+    user_id: "user_mock",
+    username: "mock-user",
+    email: "mock@example.com",
+    display_name: "Mock User",
+    org: {
+      slug: orgSlug || "mock-org"
+    },
+    mockSessionId: state.sessionId
+  };
+}
+function mockSearch(state, params) {
+  if (params.entity) {
+    const hit = state.searchCatalog.find(
+      (item) => `${item.type}:${item.id}` === params.entity || item.id === params.entity
+    );
+    return {
+      conversationId: `mock-${state.sessionId}`,
+      matches: hit ? [
+        {
+          type: hit.type,
+          id: hit.id,
+          entityRef: `${hit.type}:${hit.id}`,
+          title: hit.title,
+          description: hit.description
+        }
+      ] : [],
+      offline: false,
+      warnings: [],
+      guidance: "Mock catalog \u2014 not the live Kody search index."
+    };
+  }
+  const q = (params.query ?? "").toLowerCase().trim();
+  const matches = state.searchCatalog.filter(
+    (item) => !q || item.title.toLowerCase().includes(q) || item.description.toLowerCase().includes(q) || item.id.toLowerCase().includes(q)
+  ).slice(0, params.limit ?? 20).map((item) => ({
+    type: item.type,
+    id: item.id,
+    entityRef: `${item.type}:${item.id}`,
+    title: item.title,
+    description: item.description
+  }));
+  return {
+    conversationId: `mock-${state.sessionId}`,
+    matches,
+    offline: false,
+    warnings: [],
+    guidance: "Mock catalog \u2014 not the live Kody search index."
+  };
+}
+function mockOpenApiDocument() {
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: "Kody API (CLI mock)",
+      version: "mock",
+      description: "Subset document for the CLI mock. Unsupported operations refuse with not_implemented_in_mock."
+    },
+    paths: {
+      "/v1/search": {
+        get: {
+          operationId: "search",
+          summary: "Search the mock catalog"
+        }
+      },
+      "/v1/me": {
+        get: {
+          operationId: "metaGetCurrentUser",
+          summary: "Mock current user"
+        }
+      }
+    },
+    "x-kody-mock-operations": [...mockOpenApiOperationIds]
+  };
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  if (chunks.length === 0) return null;
+  const text = Buffer.concat(chunks).toString("utf8").trim();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function sendJson(res, status, body) {
+  const payload = JSON.stringify(body);
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": Buffer.byteLength(payload)
+  });
+  res.end(payload);
+}
+async function withMockServer(options, fn) {
+  const server = await startMockServer(options);
+  try {
+    return await fn(server);
+  } finally {
+    await server.close();
+  }
+}
+
+export {
+  isMockApiToken,
+  mintMockApiToken,
+  startMockServer,
+  ensureMockTarget,
+  withMockServer
+};
+//# sourceMappingURL=chunk-XDCOWU5R.js.map