@tappify/extension-sdk 2.0.0

package/dist/testing/index.mjs

@@ -0,0 +1,887 @@
+import {
+  installPrefix,
+  procedurePrefix
+} from "../chunk-BDCX6LRQ.mjs";
+import {
+  TapHostProvider
+} from "../chunk-4C5Z3CIK.mjs";
+import "../chunk-QHM7XNRK.mjs";
+import {
+  SERVER_ERROR_CODES,
+  createTappifyHandler,
+  readRecord,
+  readText
+} from "../chunk-ZT35X7KL.mjs";
+import {
+  CARD_KEYS,
+  QUERY_SCOPES,
+  SCOPE_KEYS
+} from "../chunk-MNDVYPEP.mjs";
+import {
+  installHostTheme,
+  registerTapMatchers,
+  tapMatchers
+} from "../chunk-IGK2AP6J.mjs";
+import {
+  TapError,
+  TapServerError
+} from "../chunk-CSTYBKZC.mjs";
+
+// src/testing/client.ts
+import {
+  exportJWK,
+  generateKeyPair,
+  SignJWT
+} from "jose";
+
+// src/testing/envelope.ts
+var DEFAULT_FILTERS = {
+  range: { from: "2026-09-01", to: "2026-09-08", preset: "7d" },
+  platform: "all",
+  country: "all"
+};
+function callEnvelope(envelope) {
+  const context = {
+    projectId: envelope.install.projectId,
+    platform: envelope.filters.platform,
+    from: envelope.filters.range.from,
+    to: envelope.filters.range.to,
+    filters: envelope.filters
+  };
+  return JSON.stringify({
+    install: envelope.install,
+    context,
+    input: envelope.input,
+    credentials: envelope.credentials ?? {},
+    documents: envelope.documents ?? {},
+    event: envelope.event
+  });
+}
+function parseJson(text) {
+  try {
+    return { parsed: true, value: JSON.parse(text) };
+  } catch {
+    return { parsed: false, value: void 0 };
+  }
+}
+async function readEnvelopeResponse(response, call) {
+  const text = await response.text();
+  const body = parseJson(text);
+  const status = String(response.status);
+  if (response.ok) {
+    if (body.parsed) return body.value;
+    if (text.trim() === "") return void 0;
+    throw new TapServerError(
+      SERVER_ERROR_CODES.INTERNAL_ERROR,
+      `The extension server answered ${status} for ${call} with a body that is not JSON. Every Tappify route answers JSON, or 204 with no body.`,
+      response.status
+    );
+  }
+  const error = readRecord(body.value, "error");
+  throw new TapServerError(
+    readText(error, "code") ?? SERVER_ERROR_CODES.INTERNAL_ERROR,
+    readText(error, "message") ?? `The extension server answered ${status} for ${call} without a JSON error body.`,
+    response.status
+  );
+}
+
+// src/testing/client.ts
+var TEST_KID = "tappify-test-key";
+var TEST_ISSUER = "https://api.tappify.ai";
+var keys = null;
+function ensureKeys() {
+  keys ?? (keys = (async () => {
+    const pair = await generateKeyPair("RS256", { extractable: true });
+    const publicJwk = await exportJWK(pair.publicKey);
+    return {
+      privateKey: pair.privateKey,
+      jwks: {
+        keys: [{ ...publicJwk, kid: TEST_KID, alg: "RS256", use: "sig" }]
+      }
+    };
+  })());
+  return keys;
+}
+async function testJwks() {
+  return (await ensureKeys()).jwks;
+}
+async function signTestToken(claims = {}, options = {}) {
+  const { privateKey } = await ensureKeys();
+  const extensionId = options.extensionId ?? claims.extensionId ?? "starter";
+  return new SignJWT({
+    installId: claims.installId ?? "ins_test",
+    extensionId,
+    projectId: claims.projectId ?? "prj_north",
+    organizationId: claims.organizationId ?? "org_test",
+    scopes: claims.scopes ?? [],
+    ...claims.userId === void 0 ? {} : { userId: claims.userId }
+  }).setProtectedHeader({ alg: "RS256", kid: TEST_KID }).setIssuer(TEST_ISSUER).setAudience(`ext:${extensionId}`).setIssuedAt().setExpirationTime(options.expiresIn ?? "5m").sign(privateKey);
+}
+var HEALTH_PATH = "/tappify/health";
+function createTestClient(target, defaults = {}) {
+  if (typeof target === "function") {
+    throw new TapError(
+      "TAP_TEST_TARGET_INVALID",
+      "createTestClient() was handed a built handler instead of the options object. A handler from createTappifyHandler() verifies install tokens against the live Tappify key set, so every call the test client makes would come back 401. Pass the options themselves \u2014 createTestClient(handlerOptions) \u2014 or, when you need the handler, build it with createTappifyHandler({ ...handlerOptions, jwks: await testJwks() }) and drive it through createTapMock({ handler, extensionId: handlerOptions.extensionId }) so the test token carries the audience the handler expects."
+    );
+  }
+  const extensionId = target.extensionId;
+  const handlerPromise = testJwks().then(
+    (jwks) => createTappifyHandler({ ...target, jwks })
+  );
+  const install = {
+    id: "ins_test",
+    extensionId,
+    projectId: "prj_north",
+    organizationId: "org_test",
+    ...defaults.install
+  };
+  const filters = defaults.filters ?? DEFAULT_FILTERS;
+  const origin = defaults.origin ?? "https://vendor.test";
+  let sent = 0;
+  function envelope(input, event) {
+    return callEnvelope({
+      install,
+      filters,
+      input,
+      credentials: defaults.credentials,
+      documents: defaults.documents,
+      event
+    });
+  }
+  async function send(method, path, body) {
+    const handler = await handlerPromise;
+    sent += 1;
+    const headers = new Headers({
+      "content-type": "application/json",
+      "x-tappify-event-id": defaults.eventId ?? `evt_${path}_${String(sent)}`
+    });
+    if (path !== HEALTH_PATH) {
+      const token = await signTestToken(
+        {
+          installId: install.id,
+          extensionId: install.extensionId,
+          projectId: install.projectId,
+          organizationId: install.organizationId,
+          scopes: defaults.scopes ?? []
+        },
+        { extensionId }
+      );
+      headers.set("authorization", `Bearer ${token}`);
+    }
+    return handler(
+      new Request(`${origin}${path}`, {
+        method,
+        headers,
+        ...body === void 0 ? {} : { body }
+      })
+    );
+  }
+  async function call(method, path, body) {
+    return readEnvelopeResponse(
+      await send(method, path, body),
+      `${method} ${path}`
+    );
+  }
+  return {
+    health: async () => await call("GET", HEALTH_PATH),
+    metrics: async (input) => await call(
+      "POST",
+      "/tappify/metrics",
+      envelope(input)
+    ),
+    tool: (id, input) => call("POST", `/tappify/tools/${id}`, envelope(input)),
+    mention: async (id, query) => await call(
+      "GET",
+      `/tappify/mentions/${id}?q=${encodeURIComponent(query)}`
+    ),
+    action: (id, input) => call("POST", `/tappify/actions/${id}`, envelope(input)),
+    procedure: (name, input = {}) => call("POST", `/tappify/procedures/${name}`, envelope(input)),
+    context: async (id) => await call("GET", `/tappify/context/${id}`),
+    event: async (name, payload) => {
+      await call("POST", "/tappify/events", envelope({}, { name, payload }));
+    },
+    work: (operation, input) => call("POST", `/tappify/work/${operation}`, envelope(input)),
+    raw: (method, path, body) => send(method, path, body === void 0 ? void 0 : JSON.stringify(body))
+  };
+}
+
+// src/testing/fixtures.ts
+var fixtureApps = [
+  {
+    id: "app_ios",
+    name: "Northlight",
+    platform: "ios",
+    storeId: "1490000001",
+    bundleId: "ai.tappify.northlight"
+  },
+  {
+    id: "app_android",
+    name: "Northlight",
+    platform: "android",
+    storeId: "ai.tappify.northlight",
+    bundleId: "ai.tappify.northlight"
+  }
+];
+var fixtureReleases = [
+  {
+    id: "rel_42",
+    version: "4.2.0",
+    build: "118",
+    platform: "ios",
+    state: "ready_for_sale",
+    shippedAt: "2026-09-01T09:00:00.000Z"
+  },
+  {
+    id: "rel_41",
+    version: "4.1.0",
+    build: "107",
+    platform: "ios",
+    state: "ready_for_sale",
+    shippedAt: "2026-08-11T09:00:00.000Z"
+  },
+  {
+    id: "rel_a42",
+    version: "4.2.0",
+    build: "4200",
+    platform: "android",
+    state: "published",
+    shippedAt: "2026-09-02T09:00:00.000Z"
+  }
+];
+var fixtureKeywords = [
+  {
+    id: "kw_1",
+    term: "photo editor",
+    platform: "ios",
+    country: "US",
+    position: 4,
+    popularity: 6.6
+  },
+  {
+    id: "kw_2",
+    term: "collage maker",
+    platform: "ios",
+    country: "US",
+    position: 11,
+    popularity: 5.3
+  },
+  {
+    id: "kw_3",
+    term: "photo editor",
+    platform: "android",
+    country: "US",
+    position: 7,
+    popularity: 6
+  }
+];
+var fixtureListings = [
+  {
+    platform: "ios",
+    country: "US",
+    locale: "en-US",
+    title: "Northlight \u2014 Photo Editor",
+    subtitle: "Edit, collage, share",
+    description: "Northlight turns a camera roll into a finished post.",
+    keywords: ["photo", "editor", "collage"],
+    updatedAt: "2026-08-28T12:00:00.000Z"
+  }
+];
+var fixtureProject = {
+  project: {
+    id: "prj_north",
+    name: "Northlight",
+    platforms: ["ios", "android"]
+  },
+  apps: fixtureApps,
+  releases: fixtureReleases
+};
+var SERIES_VALUES = {
+  downloads: [1180, 1240, 1310, 1290, 1402, 1512, 1488],
+  impressions: [21400, 22150, 22980, 22110, 24020, 25510, 25010],
+  page_views: [8120, 8340, 8710, 8290, 9110, 9640, 9420],
+  conversion_rate: [0.145, 0.149, 0.15, 0.156, 0.152, 0.157, 0.158]
+};
+function week() {
+  return [
+    "2026-09-01",
+    "2026-09-02",
+    "2026-09-03",
+    "2026-09-04",
+    "2026-09-05",
+    "2026-09-06",
+    "2026-09-07"
+  ];
+}
+function fixtureSeries(metric) {
+  const points = week().map((at, index) => ({
+    at,
+    value: SERIES_VALUES[metric][index]
+  }));
+  return {
+    metric,
+    unit: metric === "conversion_rate" ? "ratio" : "count",
+    points
+  };
+}
+var fixtureReviews = {
+  total: 3,
+  averageRating: 3.7,
+  reviews: [
+    {
+      id: "rev_1",
+      platform: "ios",
+      country: "US",
+      rating: 5,
+      title: "Fast and clean",
+      body: "The new collage layouts are exactly what I wanted.",
+      author: "kbrady",
+      submittedAt: "2026-09-05T18:22:00.000Z",
+      replied: false
+    },
+    {
+      id: "rev_2",
+      platform: "ios",
+      country: "GB",
+      rating: 2,
+      title: "Crashes on export",
+      body: "Since 4.2 the export button closes the app.",
+      author: null,
+      submittedAt: "2026-09-04T08:10:00.000Z",
+      replied: true
+    },
+    {
+      id: "rev_3",
+      platform: "android",
+      country: "DE",
+      rating: 4,
+      title: null,
+      body: "Gute App, aber der Export dauert lange.",
+      author: "mgruber",
+      submittedAt: "2026-09-03T16:45:00.000Z",
+      replied: false
+    }
+  ]
+};
+var fixtureCrashes = {
+  crashFreeRate: 99.42,
+  issues: [
+    {
+      id: "crash_1",
+      title: "ExportSession.finish \u2014 index out of range",
+      count: 214,
+      build: "118",
+      firstSeenAt: "2026-09-01T11:02:00.000Z",
+      lastSeenAt: "2026-09-07T21:40:00.000Z"
+    },
+    {
+      id: "crash_2",
+      title: "PhotoLibrary.load \u2014 permission revoked",
+      count: 37,
+      build: "118",
+      firstSeenAt: "2026-09-02T07:15:00.000Z",
+      lastSeenAt: "2026-09-06T13:05:00.000Z"
+    }
+  ]
+};
+var fixtureRevenue = {
+  currency: "USD",
+  mrr: 41200,
+  refunds: 18,
+  points: week().map((at, index) => ({
+    at,
+    value: [1310, 1355, 1401, 1388, 1470, 1525, 1502][index]
+  }))
+};
+var fixtures = {
+  project: fixtureProject,
+  apps: fixtureApps,
+  releases: fixtureReleases,
+  keywords: fixtureKeywords,
+  listings: fixtureListings,
+  reviews: fixtureReviews,
+  crashes: fixtureCrashes,
+  revenue: fixtureRevenue,
+  series: fixtureSeries
+};
+function answerFixtureQuery(query) {
+  switch (query.kind) {
+    case "project":
+      return structuredClone(fixtureProject);
+    case "series":
+      return structuredClone(fixtureSeries(query.metric));
+    case "keywords":
+      return structuredClone({ keywords: fixtureKeywords });
+    case "listing":
+      return structuredClone({ listings: fixtureListings });
+    case "reviews":
+      return structuredClone(fixtureReviews);
+    case "crashes":
+      return structuredClone(fixtureCrashes);
+    case "revenue":
+      return structuredClone(fixtureRevenue);
+  }
+}
+
+// src/testing/mock.ts
+var SINGLETON_ID = "singleton";
+var PROBE_KEYS = /* @__PURE__ */ new Set([
+  "then",
+  "toJSON",
+  "$$typeof",
+  "constructor",
+  "prototype",
+  "valueOf",
+  "toString",
+  "inspect",
+  "asymmetricMatch",
+  "nodeType"
+]);
+function unknownCollectionError(collection) {
+  return new TapError(
+    "TAP_UNKNOWN_COLLECTION",
+    `This mock exposes no storage collection called "${collection}". createTapMock({ storage: \u2026 }) was given an explicit map, so only the collections it names exist. Add "${collection}" to that map, or drop the storage option to expose every collection.`
+  );
+}
+function singletonView(handle) {
+  return {
+    get: () => handle.get(),
+    set: (document2) => handle.set(document2),
+    patch: (partial) => handle.patch(partial)
+  };
+}
+function collectionView(handle) {
+  return {
+    list: (listOptions) => handle.list(listOptions),
+    get: (id) => handle.get(id),
+    put: (id, document2) => handle.put(id, document2),
+    delete: (id) => handle.delete(id)
+  };
+}
+function scopeError(scope) {
+  return new TapError(
+    "TAP_SCOPE_MISSING",
+    `This install has not granted ${scope}. Declare it under "scopes" in tappify.extension.json, or pass scopes: ["${scope}"] to renderWithTap() to test the granted path.`
+  );
+}
+function asObject(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+function createTapMock(options = {}) {
+  const granted = new Set(options.scopes ?? SCOPE_KEYS);
+  const listeners = /* @__PURE__ */ new Map();
+  const eventHandlers = /* @__PURE__ */ new Map();
+  const state = /* @__PURE__ */ new Map();
+  const store = /* @__PURE__ */ new Map();
+  const portal = document.createElement("div");
+  portal.dataset.tapPortal = "true";
+  const calls = {
+    navigations: [],
+    searches: [],
+    toasts: [],
+    confirms: [],
+    actions: [],
+    telemetry: [],
+    chats: [],
+    externals: [],
+    downloads: [],
+    copies: [],
+    cards: [],
+    expands: 0,
+    settingsOpens: 0
+  };
+  const emitChange = (key) => {
+    for (const listener of listeners.get(key) ?? []) listener();
+  };
+  const subscribe = (key, listener) => {
+    const set = listeners.get(key) ?? /* @__PURE__ */ new Set();
+    set.add(listener);
+    listeners.set(key, set);
+    return () => {
+      set.delete(listener);
+    };
+  };
+  const withStorage = (run) => granted.has("storage:write") ? Promise.resolve(run()) : Promise.reject(scopeError("storage:write"));
+  const bucket = (collection) => {
+    const existing = store.get(collection);
+    if (existing) return existing;
+    const created = [];
+    store.set(collection, created);
+    return created;
+  };
+  function buildHandle(collection) {
+    const find = (id) => bucket(collection).find((entry) => entry.id === id);
+    const write = (id, data) => {
+      const items = bucket(collection);
+      const index = items.findIndex((entry) => entry.id === id);
+      if (index === -1) items.push({ id, data });
+      else items[index] = { id, data };
+      emitChange(`storage:${collection}`);
+    };
+    return {
+      get: (id) => withStorage(() => find(id ?? SINGLETON_ID)?.data ?? null),
+      set: (document2) => withStorage(() => {
+        write(SINGLETON_ID, document2);
+      }),
+      patch: (partial) => withStorage(() => {
+        const merged = { ...asObject(find(SINGLETON_ID)?.data), ...partial };
+        write(SINGLETON_ID, merged);
+        return merged;
+      }),
+      list: () => withStorage(() => ({
+        items: bucket(collection).filter((entry) => entry.id !== SINGLETON_ID).map((entry) => ({ ...asObject(entry.data), id: entry.id }))
+      })),
+      put: (id, document2) => withStorage(() => {
+        write(id, document2);
+      }),
+      delete: (id) => withStorage(() => {
+        const items = bucket(collection);
+        const index = items.findIndex((entry) => entry.id === id);
+        if (index !== -1) {
+          items.splice(index, 1);
+          emitChange(`storage:${collection}`);
+        }
+      })
+    };
+  }
+  const handles = /* @__PURE__ */ new Map();
+  const kinds = options.storage;
+  const exposeHandle = (collection) => {
+    const kind = kinds?.[collection];
+    if (kinds !== void 0 && kind === void 0) {
+      throw unknownCollectionError(collection);
+    }
+    const handle = buildHandle(collection);
+    if (kind === "singleton") return singletonView(handle);
+    if (kind === "collection") return collectionView(handle);
+    return handle;
+  };
+  const handleFor = (collection) => {
+    if (PROBE_KEYS.has(collection)) return void 0;
+    const existing = handles.get(collection);
+    if (existing) return existing;
+    const created = exposeHandle(collection);
+    handles.set(collection, created);
+    return created;
+  };
+  const storageTarget = {};
+  const storage = new Proxy(storageTarget, {
+    get: (_target, property) => typeof property === "string" ? handleFor(property) : void 0,
+    has: () => true,
+    ownKeys: () => [...store.keys()],
+    getOwnPropertyDescriptor: () => ({ enumerable: true, configurable: true })
+  });
+  let calledProcedures = 0;
+  let signedToken = null;
+  function handlerToken() {
+    if (options.handlerToken !== void 0) {
+      return Promise.resolve(options.handlerToken);
+    }
+    signedToken ?? (signedToken = signTestToken(
+      {
+        installId: tap.extension.installId,
+        extensionId: tap.extension.id,
+        projectId: tap.extension.projectId,
+        organizationId: tap.auth.organizationId,
+        scopes: [...granted]
+      },
+      { extensionId: tap.extension.id }
+    ));
+    return signedToken;
+  }
+  async function callProcedure(name, input) {
+    const local = options.server?.[name];
+    if (local) return local(input);
+    if (options.handler) {
+      const path = `/tappify/procedures/${name}`;
+      calledProcedures += 1;
+      const response = await options.handler(
+        new Request(`https://vendor.test${path}`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            "x-tappify-event-id": `evt_${name}_${String(calledProcedures)}`,
+            authorization: `Bearer ${await handlerToken()}`
+          },
+          body: callEnvelope({
+            install: {
+              id: tap.extension.installId,
+              extensionId: tap.extension.id,
+              projectId: tap.extension.projectId,
+              organizationId: tap.auth.organizationId
+            },
+            filters: tap.filters,
+            input
+          })
+        })
+      );
+      return readEnvelopeResponse(response, `POST ${path}`);
+    }
+    throw new TapError(
+      "TAP_UNKNOWN_PROCEDURE",
+      `No handler is registered for the procedure "${name}". Pass server: { ${name}: input => \u2026 } or handler: <your createTappifyHandler handler> to createTapMock().`
+    );
+  }
+  const serverTarget = {};
+  const tap = {
+    extension: {
+      id: options.extensionId ?? "starter",
+      name: options.extensionName ?? "Starter",
+      installId: options.installId ?? "ins_test",
+      projectId: "prj_north"
+    },
+    env: "dev",
+    host: { version: "test", sdkMajors: [2] },
+    auth: {
+      token: "test-token",
+      user: { id: "usr_test", role: "admin" },
+      organizationId: "org_test",
+      scopes: [...granted],
+      can: (scope) => granted.has(scope)
+    },
+    project: {
+      id: "prj_north",
+      name: "Northlight",
+      platforms: ["ios", "android"],
+      apps: [],
+      releases: [],
+      keywords: [],
+      ...options.project
+    },
+    filters: { ...DEFAULT_FILTERS, ...options.filters },
+    theme: { mode: options.theme ?? "light" },
+    locale: "en-US",
+    timezone: "UTC",
+    format: {
+      number: (value, formatOptions) => new Intl.NumberFormat("en-US", formatOptions).format(value),
+      currency: (value, code) => new Intl.NumberFormat("en-US", {
+        style: "currency",
+        currency: code
+      }).format(value),
+      date: (value) => new Date(value).toISOString().slice(0, 10),
+      relative: (value) => new Date(value).toISOString()
+    },
+    nav: {
+      push: (path) => calls.navigations.push(path),
+      setSearch: (params) => calls.searches.push(params),
+      openSettings: () => {
+        calls.settingsOpens += 1;
+      },
+      openChat: (prompt, context) => calls.chats.push({ prompt, context }),
+      openExternal: (url) => calls.externals.push(url)
+    },
+    data: {
+      query: (query) => {
+        const scope = QUERY_SCOPES[query.kind];
+        if (!granted.has(scope)) return Promise.reject(scopeError(scope));
+        return Promise.resolve(answerFixtureQuery(query));
+      },
+      subscribe: (event, handler) => {
+        const key = String(event);
+        const set = eventHandlers.get(key) ?? /* @__PURE__ */ new Set();
+        const wrapped = (payload) => {
+          handler(payload);
+        };
+        set.add(wrapped);
+        eventHandlers.set(key, set);
+        return () => {
+          set.delete(wrapped);
+        };
+      }
+    },
+    server: new Proxy(serverTarget, {
+      get: (_target, property) => (input) => callProcedure(String(property), input),
+      has: () => true
+    }),
+    state: {
+      get: (key) => {
+        const value = state.get(key);
+        return value === void 0 ? void 0 : value;
+      },
+      set: (key, value) => {
+        state.set(key, value);
+        emitChange(`state:${key}`);
+      },
+      subscribe: (key, handler) => subscribe(`state:${key}`, handler)
+    },
+    ui: {
+      size: options.size ?? "slot",
+      toast: (message, tone = "neutral") => calls.toasts.push({ message, tone }),
+      confirm: (confirmOptions) => {
+        calls.confirms.push(confirmOptions);
+        return Promise.resolve(options.confirmAnswer ?? true);
+      },
+      openInChat: (card) => calls.cards.push(card),
+      expand: () => {
+        calls.expands += 1;
+      },
+      download: (blob, filename) => calls.downloads.push({ filename, size: blob.size }),
+      copy: (text) => {
+        calls.copies.push(text);
+        return Promise.resolve();
+      }
+    },
+    context: options.context ?? {},
+    params: options.params ?? {},
+    storage,
+    telemetry: {
+      event: (name, props) => calls.telemetry.push({ name, props })
+    },
+    actions: {
+      run: (actionId, input) => {
+        calls.actions.push({ actionId, input });
+        return Promise.resolve({
+          id: `run_${String(calls.actions.length)}`,
+          actionId,
+          status: "pending",
+          requestedAt: (/* @__PURE__ */ new Date(0)).toISOString()
+        });
+      }
+    },
+    invalidate: () => void 0,
+    __portal: portal,
+    __subscribe: subscribe
+  };
+  return {
+    tap,
+    calls,
+    portal,
+    documents: (collection, documentId) => bucket(collection).filter((entry) => documentId === void 0 || entry.id === documentId).map((entry) => entry.data),
+    emit: (event, payload) => {
+      for (const handler of eventHandlers.get(String(event)) ?? []) {
+        handler(payload);
+      }
+    },
+    setFilters: (filters) => {
+      tap.filters = filters;
+      emitChange("filters");
+    },
+    setSize: (size) => {
+      tap.ui = { ...tap.ui, size };
+      emitChange("size");
+    },
+    setTheme: (mode) => {
+      tap.theme = { mode };
+      emitChange("theme");
+    },
+    setParams: (params) => {
+      tap.params = params;
+      emitChange("params");
+    }
+  };
+}
+
+// src/testing/render.tsx
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import {
+  render
+} from "@testing-library/react";
+import { jsx } from "react/jsx-runtime";
+function renderWithTap(ui, options = {}) {
+  const mock = options.mock ?? createTapMock(options);
+  const queryClient = options.queryClient ?? new QueryClient({
+    defaultOptions: { queries: { retry: false, gcTime: 0 } }
+  });
+  const installId = mock.tap.extension.installId;
+  mock.tap.invalidate = (name) => {
+    void queryClient.invalidateQueries({
+      queryKey: name === void 0 ? installPrefix(installId) : procedurePrefix(installId, name)
+    });
+  };
+  function Wrapper({ children }) {
+    return /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ jsx(TapHostProvider, { tap: mock.tap, children }) });
+  }
+  const result = render(ui, { wrapper: Wrapper, container: options.container });
+  result.baseElement.append(mock.portal);
+  return { ...result, tap: mock.tap, mock, queryClient };
+}
+
+// src/testing/validators.ts
+function record(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+function list(value) {
+  return Array.isArray(value) ? value : null;
+}
+function isPoint(value) {
+  const pair = list(value);
+  return pair !== null && pair.length === 2 && typeof pair[0] === "string" && typeof pair[1] === "number";
+}
+function validateMetricsResponse(response, metrics) {
+  const series = list(record(response)?.series);
+  if (series === null) {
+    return [
+      'A metrics response is { "series": [...] }. Return one entry per declared metric, even when it has no points.'
+    ];
+  }
+  const issues = [];
+  const declared = new Map(metrics.map((metric) => [metric.key, metric]));
+  for (const [index, entry] of series.entries()) {
+    const item = record(entry);
+    const key = typeof item?.metric === "string" ? item.metric : null;
+    if (item === null || key === null) {
+      issues.push(`series[${String(index)}] has no "metric" key.`);
+      continue;
+    }
+    const metric = declared.get(key);
+    if (metric === void 0) {
+      issues.push(
+        `series[${String(index)}] reports "${key}", which is not declared under contributes.connector.metrics.`
+      );
+      continue;
+    }
+    if (item.unit !== metric.unit) {
+      issues.push(
+        `series[${String(index)}] reports unit "${String(item.unit)}" but "${key}" is declared as "${metric.unit}".`
+      );
+    }
+    const points = list(item.points);
+    if (points === null) {
+      issues.push(`series[${String(index)}] has no "points" array.`);
+      continue;
+    }
+    for (const [pointIndex, point] of points.entries()) {
+      if (!isPoint(point)) {
+        issues.push(
+          `series[${String(index)}].points[${String(pointIndex)}] must be a two-element [timestamp, value] pair: a string and a number.`
+        );
+      }
+    }
+  }
+  return issues;
+}
+function validateToolResponse(value, returns) {
+  const body = record(value);
+  if (body === null) {
+    return [
+      `A "${returns}" tool returns an object the host draws as a card, not ${typeof value}.`
+    ];
+  }
+  return CARD_KEYS[returns].filter((key) => !(key in body)).map(
+    (key) => `A "${returns}" tool response needs a "${key}" key; the host draws the card from it.`
+  );
+}
+export {
+  answerFixtureQuery,
+  createTapMock,
+  createTestClient,
+  fixtureApps,
+  fixtureCrashes,
+  fixtureKeywords,
+  fixtureListings,
+  fixtureProject,
+  fixtureReleases,
+  fixtureRevenue,
+  fixtureReviews,
+  fixtureSeries,
+  fixtures,
+  installHostTheme,
+  registerTapMatchers,
+  renderWithTap,
+  signTestToken,
+  tapMatchers,
+  testJwks,
+  validateMetricsResponse,
+  validateToolResponse
+};
+//# sourceMappingURL=index.mjs.map