@tappify/extension-sdk 2.0.0

package/dist/testing/index.cjs

@@ -0,0 +1,887 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunk5AAPD5WVcjs = require('../chunk-5AAPD5WV.cjs');
+
+
+var _chunk7KIKOH5Hcjs = require('../chunk-7KIKOH5H.cjs');
+require('../chunk-OPPYEA7F.cjs');
+
+
+
+
+
+var _chunkRMUWRESKcjs = require('../chunk-RMUWRESK.cjs');
+
+
+
+
+var _chunkPYJMJF44cjs = require('../chunk-PYJMJF44.cjs');
+
+
+
+
+var _chunk3YWVYA42cjs = require('../chunk-3YWVYA42.cjs');
+
+
+
+var _chunk2DBSVKAUcjs = require('../chunk-2DBSVKAU.cjs');
+
+// src/testing/client.ts
+
+
+
+
+var _jose = require('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: _nullishCoalesce(envelope.credentials, () => ( {})),
+    documents: _nullishCoalesce(envelope.documents, () => ( {})),
+    event: envelope.event
+  });
+}
+function parseJson(text) {
+  try {
+    return { parsed: true, value: JSON.parse(text) };
+  } catch (e) {
+    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 (0, _chunk2DBSVKAUcjs.TapServerError)(
+      _chunkRMUWRESKcjs.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 = _chunkRMUWRESKcjs.readRecord.call(void 0, body.value, "error");
+  throw new (0, _chunk2DBSVKAUcjs.TapServerError)(
+    _nullishCoalesce(_chunkRMUWRESKcjs.readText.call(void 0, error, "code"), () => ( _chunkRMUWRESKcjs.SERVER_ERROR_CODES.INTERNAL_ERROR)),
+    _nullishCoalesce(_chunkRMUWRESKcjs.readText.call(void 0, 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() {
+  _nullishCoalesce(keys, () => ( (keys = (async () => {
+    const pair = await _jose.generateKeyPair.call(void 0, "RS256", { extractable: true });
+    const publicJwk = await _jose.exportJWK.call(void 0, 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 = _nullishCoalesce(_nullishCoalesce(options.extensionId, () => ( claims.extensionId)), () => ( "starter"));
+  return new (0, _jose.SignJWT)({
+    installId: _nullishCoalesce(claims.installId, () => ( "ins_test")),
+    extensionId,
+    projectId: _nullishCoalesce(claims.projectId, () => ( "prj_north")),
+    organizationId: _nullishCoalesce(claims.organizationId, () => ( "org_test")),
+    scopes: _nullishCoalesce(claims.scopes, () => ( [])),
+    ...claims.userId === void 0 ? {} : { userId: claims.userId }
+  }).setProtectedHeader({ alg: "RS256", kid: TEST_KID }).setIssuer(TEST_ISSUER).setAudience(`ext:${extensionId}`).setIssuedAt().setExpirationTime(_nullishCoalesce(options.expiresIn, () => ( "5m"))).sign(privateKey);
+}
+var HEALTH_PATH = "/tappify/health";
+function createTestClient(target, defaults = {}) {
+  if (typeof target === "function") {
+    throw new (0, _chunk2DBSVKAUcjs.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) => _chunkRMUWRESKcjs.createTappifyHandler.call(void 0, { ...target, jwks })
+  );
+  const install = {
+    id: "ins_test",
+    extensionId,
+    projectId: "prj_north",
+    organizationId: "org_test",
+    ...defaults.install
+  };
+  const filters = _nullishCoalesce(defaults.filters, () => ( DEFAULT_FILTERS));
+  const origin = _nullishCoalesce(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": _nullishCoalesce(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: _nullishCoalesce(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 (0, _chunk2DBSVKAUcjs.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 (0, _chunk2DBSVKAUcjs.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(_nullishCoalesce(options.scopes, () => ( _chunkPYJMJF44cjs.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 _nullishCoalesce(listeners.get(key), () => ( []))) listener();
+  };
+  const subscribe = (key, listener) => {
+    const set = _nullishCoalesce(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(() => _nullishCoalesce(_optionalChain([find, 'call', _ => _(_nullishCoalesce(id, () => ( SINGLETON_ID))), 'optionalAccess', _2 => _2.data]), () => ( null))),
+      set: (document2) => withStorage(() => {
+        write(SINGLETON_ID, document2);
+      }),
+      patch: (partial) => withStorage(() => {
+        const merged = { ...asObject(_optionalChain([find, 'call', _3 => _3(SINGLETON_ID), 'optionalAccess', _4 => _4.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 = _optionalChain([kinds, 'optionalAccess', _5 => _5[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);
+    }
+    _nullishCoalesce(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 = _optionalChain([options, 'access', _6 => _6.server, 'optionalAccess', _7 => _7[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 (0, _chunk2DBSVKAUcjs.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: _nullishCoalesce(options.extensionId, () => ( "starter")),
+      name: _nullishCoalesce(options.extensionName, () => ( "Starter")),
+      installId: _nullishCoalesce(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: _nullishCoalesce(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 = _chunkPYJMJF44cjs.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 = _nullishCoalesce(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: _nullishCoalesce(options.size, () => ( "slot")),
+      toast: (message, tone = "neutral") => calls.toasts.push({ message, tone }),
+      confirm: (confirmOptions) => {
+        calls.confirms.push(confirmOptions);
+        return Promise.resolve(_nullishCoalesce(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: _nullishCoalesce(options.context, () => ( {})),
+    params: _nullishCoalesce(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 _nullishCoalesce(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
+var _reactquery = require('@tanstack/react-query');
+
+
+var _react = require('@testing-library/react');
+var _jsxruntime = require('react/jsx-runtime');
+function renderWithTap(ui, options = {}) {
+  const mock = _nullishCoalesce(options.mock, () => ( createTapMock(options)));
+  const queryClient = _nullishCoalesce(options.queryClient, () => ( new (0, _reactquery.QueryClient)({
+    defaultOptions: { queries: { retry: false, gcTime: 0 } }
+  })));
+  const installId = mock.tap.extension.installId;
+  mock.tap.invalidate = (name) => {
+    void queryClient.invalidateQueries({
+      queryKey: name === void 0 ? _chunk5AAPD5WVcjs.installPrefix.call(void 0, installId) : _chunk5AAPD5WVcjs.procedurePrefix.call(void 0, installId, name)
+    });
+  };
+  function Wrapper({ children }) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _reactquery.QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunk7KIKOH5Hcjs.TapHostProvider, { tap: mock.tap, children }) });
+  }
+  const result = _react.render.call(void 0, 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(_optionalChain([record, 'call', _8 => _8(response), 'optionalAccess', _9 => _9.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 _optionalChain([item, 'optionalAccess', _10 => _10.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 _chunkPYJMJF44cjs.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.`
+  );
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.answerFixtureQuery = answerFixtureQuery; exports.createTapMock = createTapMock; exports.createTestClient = createTestClient; exports.fixtureApps = fixtureApps; exports.fixtureCrashes = fixtureCrashes; exports.fixtureKeywords = fixtureKeywords; exports.fixtureListings = fixtureListings; exports.fixtureProject = fixtureProject; exports.fixtureReleases = fixtureReleases; exports.fixtureRevenue = fixtureRevenue; exports.fixtureReviews = fixtureReviews; exports.fixtureSeries = fixtureSeries; exports.fixtures = fixtures; exports.installHostTheme = _chunk3YWVYA42cjs.installHostTheme; exports.registerTapMatchers = _chunk3YWVYA42cjs.registerTapMatchers; exports.renderWithTap = renderWithTap; exports.signTestToken = signTestToken; exports.tapMatchers = _chunk3YWVYA42cjs.tapMatchers; exports.testJwks = testJwks; exports.validateMetricsResponse = validateMetricsResponse; exports.validateToolResponse = validateToolResponse;
+//# sourceMappingURL=index.cjs.map