@pythia-software/query-table-core 0.9.7 → 0.9.9

package/dist/index.js

@@ -23,10 +23,10 @@ function parseCellDisplay(raw, context = "cell display") {
     throw Error(`${context}: ${reason}`);
   };
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return fail("expected an object");
-  const record2 = raw;
-  if (typeof record2.kind !== "string" || !Object.prototype.hasOwnProperty.call(options, record2.kind)) return fail("unsupported kind");
-  const allowed = options[record2.kind];
-  for (const [key, value] of Object.entries(record2)) {
+  const record3 = raw;
+  if (typeof record3.kind !== "string" || !Object.prototype.hasOwnProperty.call(options, record3.kind)) return fail("unsupported kind");
+  const allowed = options[record3.kind];
+  for (const [key, value] of Object.entries(record3)) {
     if (key === "kind") continue;
     const rule = Object.prototype.hasOwnProperty.call(allowed, key) ? allowed[key] : void 0;
     if (!rule) return fail(`unsupported option ${key}`);
@@ -40,13 +40,16 @@ function parseCellDisplay(raw, context = "cell display") {
     if (key === "pattern" && value.length > 160) return fail("pattern must be at most 160 characters");
   }
   return {
-    ...record2,
-    ...record2.labels ? { labels: { ...record2.labels } } : {},
-    ...record2.tones ? { tones: { ...record2.tones } } : {}
+    ...record3,
+    ...record3.labels ? { labels: { ...record3.labels } } : {},
+    ...record3.tones ? { tones: { ...record3.tones } } : {}
   };
 }
 
 // src/properties.ts
+function isPropertyFieldLoaded(field, loadedFields) {
+  return !loadedFields || loadedFields.includes(field.name) || field.source.kind === "derived" && field.source.dependencies !== void 0 && field.source.dependencies.every((name) => loadedFields.includes(name));
+}
 var MAX_PROPERTIES = 200;
 var string = (value, max = 256) => typeof value === "string" && value.length > 0 && value.length <= max;
 var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
@@ -444,6 +447,71 @@ function renderItemPageTemplate(template, schema, row, id, query) {
   return fillUrlTemplate(template, ITEM_PAGE_TOKENS, (token) => token === "id" ? id : token === "query" ? query : readFieldValue(schema.fields.find((field) => field.name === token.slice(6)), row));
 }
 
+// src/jsonInspection.ts
+var MAX_JSON_INSPECTIONS = 200;
+var MAX_JSON_PATHS = 5e3;
+var record2 = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
+var text = (x, max) => typeof x === "string" && x.length > 0 && x.length <= max;
+function isJsonPath(path) {
+  return text(path, 1e4) && /^\$(?:\[(?:0|[1-9]\d*|"(?:[^"\\\x00-\x1f]|\\(?:["\\/bfnrt]|u[\da-fA-F]{4}))*")\])*$/.test(path);
+}
+function isJsonBucketId(path) {
+  if (!text(path, 10032)) return false;
+  const index = path.lastIndexOf(":bucket:");
+  return index > 0 && isJsonPath(path.slice(0, index)) && /^(?:0|[1-9]\d*)$/.test(path.slice(index + 8)) && Number.isSafeInteger(Number(path.slice(index + 8))) && Number(path.slice(index + 8)) >= 20 && Number(path.slice(index + 8)) % 20 === 0;
+}
+function jsonInspectionScopeKey(scope) {
+  return JSON.stringify([scope.dataset, scope.rowId, scope.field]);
+}
+function parseJsonInspectionState(input) {
+  if (!record2(input) || input.version !== 1 || typeof input.open !== "boolean" || typeof input.raw !== "boolean" || typeof input.search !== "string" || input.search.length > 1e4 || input.searchMode !== "filter" && input.searchMode !== "find" || typeof input.visibleEntryLimit !== "number" || !Number.isInteger(input.visibleEntryLimit) || input.visibleEntryLimit < 1 || input.visibleEntryLimit > 1e4)
+    throw Error("Invalid or unsupported JSON inspection state.");
+  const paths = (value, valid) => {
+    if (!Array.isArray(value) || value.length > MAX_JSON_PATHS || !value.every(valid) || new Set(value).size !== value.length)
+      throw Error("Invalid JSON inspection paths.");
+    return value.slice();
+  };
+  const state = {
+    version: 1,
+    open: input.open,
+    search: input.search,
+    searchMode: input.searchMode,
+    raw: input.raw,
+    collapsedPaths: paths(input.collapsedPaths, isJsonPath),
+    expandedBuckets: paths(input.expandedBuckets, isJsonBucketId),
+    visibleEntryLimit: input.visibleEntryLimit,
+    searchOverrides: []
+  };
+  if (input.selectedMatch !== void 0) {
+    const match = input.selectedMatch;
+    if (!record2(match) || !isJsonPath(match.path) || match.part !== "key" && match.part !== "value" && match.part !== "path" || typeof match.start !== "number" || !Number.isSafeInteger(match.start) || match.start < 0 || match.start > 1048576)
+      throw Error("Invalid JSON match identity.");
+    state.selectedMatch = { path: match.path, part: match.part, start: match.start };
+  }
+  if (!Array.isArray(input.searchOverrides) || input.searchOverrides.length > MAX_JSON_PATHS) throw Error("Invalid JSON search expansion overrides.");
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of input.searchOverrides) {
+    if (!record2(entry) || !(isJsonPath(entry.path) || isJsonBucketId(entry.path)) || typeof entry.expanded !== "boolean" || seen.has(entry.path))
+      throw Error("Invalid JSON search expansion override.");
+    seen.add(entry.path);
+    state.searchOverrides.push({ path: entry.path, expanded: entry.expanded });
+  }
+  return state;
+}
+function parseJsonInspections(input) {
+  if (!Array.isArray(input) || input.length > MAX_JSON_INSPECTIONS) throw Error("Invalid JSON inspection scopes.");
+  const seen = /* @__PURE__ */ new Set();
+  return input.map((entry) => {
+    if (!record2(entry) || !text(entry.dataset, 256) || !text(entry.field, 256) || !(text(entry.rowId, 1e3) || typeof entry.rowId === "number" && Number.isFinite(entry.rowId)))
+      throw Error("Invalid JSON inspection scope.");
+    const scope = { dataset: entry.dataset, rowId: entry.rowId, field: entry.field };
+    const key = jsonInspectionScopeKey(scope);
+    if (seen.has(key)) throw Error("Duplicate JSON inspection scope.");
+    seen.add(key);
+    return { ...scope, state: parseJsonInspectionState(entry.state) };
+  });
+}
+
 // src/metricNormalize.ts
 var METRIC_OPTION_SPECS = {
   top: {
@@ -559,16 +627,16 @@ var METRIC_OPTION_SPECS = {
 };
 function normalizeMetricOptions(raw) {
   const out = {}, diagnostics = [];
-  const record2 = (x) => !!x && typeof x === "object" && !Array.isArray(x);
+  const record3 = (x) => !!x && typeof x === "object" && !Array.isArray(x);
   const copy = (input, specs) => {
     const result = {};
     for (const [key, spec] of Object.entries(specs)) {
       const v = input[key];
       if (v === void 0) continue;
       if (spec === "minCount") {
-        const m = record2(v) ? copy(v, METRIC_OPTION_SPECS.minCount) : v;
+        const m = record3(v) ? copy(v, METRIC_OPTION_SPECS.minCount) : v;
         const named = (x) => x === void 0 || typeof x === "string" && !!x && x.length <= 256;
-        if (record2(m) ? m.min !== void 0 && m.distinct === void 0 !== (m.sum === void 0) && named(m.distinct) && named(m.sum) : typeof m === "number" && Number.isSafeInteger(m) && m >= 1 && m <= 1e6)
+        if (record3(m) ? m.min !== void 0 && m.distinct === void 0 !== (m.sum === void 0) && named(m.distinct) && named(m.sum) : typeof m === "number" && Number.isSafeInteger(m) && m >= 1 && m <= 1e6)
           result[key] = m;
         else diagnostics.push(`Invalid metric ${key}.`);
         continue;
@@ -584,7 +652,7 @@ function normalizeMetricOptions(raw) {
     copy(raw, METRIC_OPTION_SPECS.top)
   );
   if (raw.window !== void 0) {
-    if (record2(raw.window)) {
+    if (record3(raw.window)) {
       const w = copy(raw.window, METRIC_OPTION_SPECS.window);
       const periods = raw.window.periods;
       if (periods === "all" || Number.isSafeInteger(periods) && periods >= 0 && periods <= 1e6)
@@ -594,12 +662,12 @@ function normalizeMetricOptions(raw) {
     } else diagnostics.push("Invalid metric window.");
   }
   if (raw.dateGrouping !== void 0) {
-    if (record2(raw.dateGrouping)) {
+    if (record3(raw.dateGrouping)) {
       const d = copy(raw.dateGrouping, METRIC_OPTION_SPECS.dateGrouping);
       if (typeof d.field !== "string" || !d.field || d.field.length > 256 || !d.interval || typeof d.includeEmpty !== "boolean" || !d.range)
         diagnostics.push("Invalid metric date grouping.");
       const occurrence = raw.dateGrouping.occurrence;
-      if (record2(occurrence)) {
+      if (record3(occurrence)) {
         const o = copy(occurrence, METRIC_OPTION_SPECS.occurrence);
         if (!o.interval || typeof o.includeEmpty !== "boolean")
           diagnostics.push("Invalid metric date grouping occurrence.");
@@ -610,32 +678,32 @@ function normalizeMetricOptions(raw) {
     } else diagnostics.push("Invalid metric date grouping.");
   }
   if (raw.display !== void 0) {
-    if (record2(raw.display)) {
+    if (record3(raw.display)) {
       if (typeof raw.display.kind !== "string")
         diagnostics.push("Invalid metric display kind.");
       const d = copy(raw.display, METRIC_OPTION_SPECS.display);
       for (const k of ["xScale", "yScale"]) {
-        if (record2(raw.display[k]))
+        if (record3(raw.display[k]))
           d[k] = copy(raw.display[k], METRIC_OPTION_SPECS.scale);
         else if (raw.display[k] !== void 0)
           diagnostics.push(`Invalid metric ${k}.`);
       }
       for (const k of ["format", "xFormat", "yFormat"])
-        if (record2(raw.display[k]))
+        if (record3(raw.display[k]))
           d[k] = copy(raw.display[k], METRIC_OPTION_SPECS.format);
-      if (record2(raw.display.list))
+      if (record3(raw.display.list))
         d.list = copy(raw.display.list, METRIC_OPTION_SPECS.list);
-      if (record2(raw.display.pivot))
+      if (record3(raw.display.pivot))
         d.pivot = copy(raw.display.pivot, METRIC_OPTION_SPECS.pivot);
       out.display = { kind: "auto", ...d };
     } else diagnostics.push("Invalid metric display.");
   }
   if (raw.distribution !== void 0) {
-    if (record2(raw.distribution))
+    if (record3(raw.distribution))
       out.distribution = copy(raw.distribution, METRIC_OPTION_SPECS.distribution);
     else diagnostics.push("Invalid metric distribution.");
   }
-  if (record2(raw.layout)) {
+  if (record3(raw.layout)) {
     const l = copy(raw.layout, METRIC_OPTION_SPECS.layout);
     for (const k of ["widthRem", "heightRem", "minWidthRem", "minHeightRem"])
       l[k] = Math.max(1, Math.min(1e3, Number(l[k] ?? 1)));
@@ -647,7 +715,7 @@ function normalizeMetricOptions(raw) {
     diagnostics.push("Invalid metric sort.");
   if (Array.isArray(raw.sort))
     out.sort = raw.sort.slice(0, 20).flatMap((s) => {
-      if (!record2(s) || typeof s.key !== "string" || !/^(value|y|count|samples|group(?:0|[1-9][0-9]?))$/.test(s.key) || !["asc", "desc"].includes(String(s.dir))) {
+      if (!record3(s) || typeof s.key !== "string" || !/^(value|y|count|samples|group(?:0|[1-9][0-9]?))$/.test(s.key) || !["asc", "desc"].includes(String(s.dir))) {
         diagnostics.push("Invalid metric sort.");
         return [];
       }
@@ -1387,6 +1455,7 @@ function normalizeQuery(input, fallback, links) {
       }
       if (Object.keys(views).length) details.views = views;
     }
+    if (raw.itemDetails.jsonInspections !== void 0) details.jsonInspections = parseJsonInspections(raw.itemDetails.jsonInspections);
     const active = raw.itemDetails.active;
     if (isRecord(active) && (active.mode === "modal" || active.mode === "expand") && modes.includes(active.mode) && (typeof active.id === "string" && active.id.length > 0 && active.id.length <= 1e3 || typeof active.id === "number" && Number.isFinite(active.id))) {
       details.active = { id: active.id, mode: active.mode };
@@ -1962,11 +2031,11 @@ function localQuerySnapshotCache(options2 = {}) {
   if (!Number.isInteger(maxEntries) || maxEntries < 1 || !Number.isFinite(maxBytes) || maxBytes < 1) throw Error("Invalid query link cache limits.");
   const storage = () => options2.storage ?? globalThis.localStorage;
   function read() {
-    const text = storage().getItem(storageKey);
-    if (!text) return [];
+    const text2 = storage().getItem(storageKey);
+    if (!text2) return [];
     let raw;
     try {
-      raw = JSON.parse(text);
+      raw = JSON.parse(text2);
     } catch {
       return [];
     }
@@ -1984,12 +2053,12 @@ function localQuerySnapshotCache(options2 = {}) {
       const entry = entries.find((e) => e.key === key && e.snapshot.code === code);
       if (entry) {
         entry.durable = true;
-        let text = JSON.stringify(entries);
-        while (text.length * 2 > maxBytes && entries.length > 1) {
+        let text2 = JSON.stringify(entries);
+        while (text2.length * 2 > maxBytes && entries.length > 1) {
           entries.splice(entries[0] === entry ? 1 : 0, 1);
-          text = JSON.stringify(entries);
+          text2 = JSON.stringify(entries);
         }
-        if (text.length * 2 <= maxBytes) storage().setItem(storageKey, text);
+        if (text2.length * 2 <= maxBytes) storage().setItem(storageKey, text2);
       }
     },
     get(key, code) {
@@ -2003,26 +2072,26 @@ function localQuerySnapshotCache(options2 = {}) {
       const old = entries.find((e) => e.key === key && e.snapshot.code === snapshot.code);
       if (old) {
         if (old.snapshot.token !== snapshot.token) throw Error("A query link code cannot be overwritten.");
-        const text2 = JSON.stringify(entries);
-        if (storage().getItem(storageKey) !== text2) storage().setItem(storageKey, text2);
+        const text3 = JSON.stringify(entries);
+        if (storage().getItem(storageKey) !== text3) storage().setItem(storageKey, text3);
         return;
       }
       entries.push({ key, snapshot: validateQuerySnapshot(snapshot) });
       while (entries.length > maxEntries) entries.shift();
-      let text = JSON.stringify(entries);
-      while (text.length * 2 > maxBytes && entries.length > 1) {
+      let text2 = JSON.stringify(entries);
+      while (text2.length * 2 > maxBytes && entries.length > 1) {
         entries.shift();
-        text = JSON.stringify(entries);
+        text2 = JSON.stringify(entries);
       }
-      if (text.length * 2 > maxBytes) throw Error("This query is too large for the local link cache.");
-      storage().setItem(storageKey, text);
+      if (text2.length * 2 > maxBytes) throw Error("This query is too large for the local link cache.");
+      storage().setItem(storageKey, text2);
     }
   };
 }
 function memoryQuerySnapshotCache() {
-  let text = null;
-  return localQuerySnapshotCache({ storage: { getItem: () => text, setItem: (_key, value) => {
-    text = value;
+  let text2 = null;
+  return localQuerySnapshotCache({ storage: { getItem: () => text2, setItem: (_key, value) => {
+    text2 = value;
   } } });
 }
 var QuerySnapshotHttpError = class extends Error {
@@ -2061,10 +2130,10 @@ async function snapshotHttpError(response) {
           bytes.set(chunk, offset);
           offset += chunk.length;
         }
-        const text = new TextDecoder().decode(bytes);
-        let reason = text;
+        const text2 = new TextDecoder().decode(bytes);
+        let reason = text2;
         if (type === "application/json") {
-          const body = JSON.parse(text);
+          const body = JSON.parse(text2);
           reason = body?.message ?? body?.error?.message ?? body?.error;
           const code2 = body?.code ?? body?.error?.code;
           if (typeof code2 === "string" && /^[A-Za-z0-9_.-]{1,64}$/.test(code2)) serverCode = code2;
@@ -2762,23 +2831,23 @@ function compileFormula(source, fields, resolve, extension) {
     let match;
     if (source[pos] === "[") {
       pos++;
-      let text = "";
+      let text2 = "";
       let closed = false;
       while (pos < source.length) {
         if (source[pos] === "]") {
           if (source[pos + 1] === "]") {
-            text += "]";
+            text2 += "]";
             pos += 2;
           } else {
             pos++;
             closed = true;
             break;
           }
-        } else text += source[pos++];
+        } else text2 += source[pos++];
       }
       if (!closed)
         throw new FormulaError("Unclosed field reference.", from, pos);
-      tokens.push({ kind: "field", text, from, to: pos });
+      tokens.push({ kind: "field", text: text2, from, to: pos });
     } else if (source[pos] === '"') {
       pos++;
       while (pos < source.length && source[pos] !== '"') {
@@ -2798,9 +2867,9 @@ function compileFormula(source, fields, resolve, extension) {
       }
     } else if (source[pos] === "'") {
       const end = source.indexOf("'", pos + 1);
-      const text = end < 0 ? "" : source.slice(pos + 1, end);
+      const text2 = end < 0 ? "" : source.slice(pos + 1, end);
       throw new FormulaError(
-        end < 0 || text.length > 40 || /["\\\n]/.test(text) ? 'Text literals use double quotes ("text"), not single quotes.' : `Text literals use double quotes: write "${text}" instead of '${text}'.`,
+        end < 0 || text2.length > 40 || /["\\\n]/.test(text2) ? 'Text literals use double quotes ("text"), not single quotes.' : `Text literals use double quotes: write "${text2}" instead of '${text2}'.`,
         from,
         end < 0 ? pos + 1 : end + 1
       );
@@ -3886,24 +3955,24 @@ function planMetricSeries(query, schema, options2 = {}) {
     );
     const plan = compileMetric(source, schema, options2.resolveComputed);
     const texts = [];
-    const at = (text) => {
-      const index = texts.indexOf(text);
-      return index < 0 ? texts.push(text) - 1 : index;
+    const at = (text2) => {
+      const index = texts.indexOf(text2);
+      return index < 0 ? texts.push(text2) - 1 : index;
     };
     let reductions;
     if (c.window && (c.window.reduce ?? "total") === "total")
       reductions = plan.aggregates.map((node) => {
-        const text = source.slice(node.from, node.to);
-        if (node.name !== "AVG") return { name: node.name, part: at(text) };
-        const input = text.slice(text.indexOf("(") + 1, text.lastIndexOf(")"));
+        const text2 = source.slice(node.from, node.to);
+        if (node.name !== "AVG") return { name: node.name, part: at(text2) };
+        const input = text2.slice(text2.indexOf("(") + 1, text2.lastIndexOf(")"));
         return { name: "AVG", sum: at(`SUM(${input})`), count: at(`COUNT(${input})`) };
       });
     else at(source);
     const parts = (groupBy) => texts.map(
-      (text) => ({
+      (text2) => ({
         id: id(),
         // The whole legacy measure keeps its operation, so v1 servers run it.
-        ...text === source && c.expression === void 0 ? { op: c.op, ...c.field ? { field: c.field } : {} } : { op: "count", expression: text },
+        ...text2 === source && c.expression === void 0 ? { op: c.op, ...c.field ? { field: c.field } : {} } : { op: "count", expression: text2 },
         groupBy,
         ...scoped(groupBy)
       })
@@ -4606,8 +4675,8 @@ function createGroupingModel(inputSchema) {
     }));
     return rows.reduce((best, row) => {
       for (const term of terms) {
-        const value = (record2) => {
-          const raw = term.def ? readFieldValue(term.def, record2) : record2[schema.idField];
+        const value = (record3) => {
+          const raw = term.def ? readFieldValue(term.def, record3) : record3[schema.idField];
           if (raw == null || term.def?.type !== "datetime") return raw;
           const instant = Date.parse(String(raw));
           return Number.isFinite(instant) ? instant : null;
@@ -7364,6 +7433,119 @@ function groupSourceQuery(query, group, schema) {
   const source = exitGrouping(query);
   return { ...source, where: appendWhereTerms(source.where, terms), offset: 0 };
 }
+
+// src/attention.ts
+function validTarget(target) {
+  return typeof target.dataset === "string" && target.dataset.length > 0 && target.dataset.length <= 256 && (target.rowId === void 0 || typeof target.rowId === "string" && target.rowId.length > 0 && target.rowId.length <= 1e3 || typeof target.rowId === "number" && Number.isFinite(target.rowId)) && (target.field === void 0 || target.rowId !== void 0 && typeof target.field === "string" && target.field.length > 0 && target.field.length <= 256) && (target.path === void 0 || target.field !== void 0 && isJsonPath(target.path));
+}
+function attentionTargetKey(target) {
+  return JSON.stringify([target.dataset, target.rowId ?? null, target.field ?? null, target.path ?? null]);
+}
+var cancelled = () => new Error("Attention navigation cancelled.");
+function abortable(promise, signal) {
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      cleanup();
+      reject(cancelled());
+    };
+    const cleanup = () => signal.removeEventListener("abort", abort);
+    if (signal.aborted) {
+      reject(cancelled());
+      return;
+    }
+    signal.addEventListener("abort", abort, { once: true });
+    promise.then((value) => {
+      cleanup();
+      resolve(value);
+    }, (error) => {
+      cleanup();
+      reject(error);
+    });
+  });
+}
+function createAttentionRegistry() {
+  const providers = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let current;
+  const lookup = (target) => providers.get(attentionTargetKey(target))?.slice(-1)[0];
+  return {
+    cancel() {
+      current?.abort();
+      current = void 0;
+    },
+    register(target, provider) {
+      if (!validTarget(target)) throw Error("Invalid semantic attention target.");
+      const key = attentionTargetKey(target);
+      const entries = providers.get(key) ?? [];
+      providers.set(key, [...entries, provider]);
+      listeners.forEach((listener) => listener());
+      return () => {
+        const remaining = providers.get(key)?.filter((entry) => entry !== provider) ?? [];
+        if (remaining.length) providers.set(key, remaining);
+        else providers.delete(key);
+      };
+    },
+    whenRegistered(target, signal, except) {
+      return new Promise((resolve, reject) => {
+        const cleanup = () => {
+          listeners.delete(check);
+          signal.removeEventListener("abort", abort);
+        };
+        const abort = () => {
+          cleanup();
+          reject(cancelled());
+        };
+        const check = () => {
+          const provider = lookup(target);
+          if (provider && provider !== except) {
+            cleanup();
+            resolve(provider);
+          }
+        };
+        if (signal.aborted) {
+          reject(cancelled());
+          return;
+        }
+        listeners.add(check);
+        signal.addEventListener("abort", abort, { once: true });
+        check();
+      });
+    },
+    async resolve(target, options2) {
+      current?.abort();
+      const controller = new AbortController();
+      current = controller;
+      const signal = controller.signal;
+      const abort = () => controller.abort();
+      options2?.signal?.addEventListener("abort", abort, { once: true });
+      if (options2?.signal?.aborted) controller.abort();
+      const result = (status) => ({ status, target });
+      try {
+        if (signal.aborted) return result("cancelled");
+        if (!validTarget(target)) return result("unavailable");
+        const candidates = [
+          target,
+          { dataset: target.dataset, ...target.rowId !== void 0 ? { rowId: target.rowId } : {}, ...target.field !== void 0 ? { field: target.field } : {} },
+          { dataset: target.dataset, ...target.rowId !== void 0 ? { rowId: target.rowId } : {} },
+          { dataset: target.dataset }
+        ];
+        const provider = candidates.map(lookup).find(Boolean);
+        if (!provider) return result("unavailable");
+        if (provider.ready) await abortable(provider.ready(signal), signal);
+        if (provider.materialize && !await abortable(Promise.resolve(provider.materialize(target, signal)), signal)) return result("unavailable");
+        if (signal.aborted) return result("cancelled");
+        const revealed = await abortable(Promise.resolve(provider.reveal(target, signal)), signal);
+        return result(signal.aborted ? "cancelled" : revealed ? "revealed" : "unavailable");
+      } catch (error) {
+        if (signal.aborted) return result("cancelled");
+        throw error;
+      } finally {
+        options2?.signal?.removeEventListener("abort", abort);
+        if (current === controller) current = void 0;
+      }
+    }
+  };
+}
 export {
   AGG_OPS_BY_TYPE,
   AGG_OPS_NEEDING_FIELD,
@@ -7381,6 +7563,8 @@ export {
   MAX_HOST_QUERY_STATE_BYTES,
   MAX_HOST_QUERY_VALUES,
   MAX_HOST_QUERY_VALUE_LENGTH,
+  MAX_JSON_INSPECTIONS,
+  MAX_JSON_PATHS,
   MAX_METRIC_WINDOW_PERIODS,
   MAX_ORDER_BY_TERMS,
   MAX_PROPERTIES,
@@ -7408,6 +7592,7 @@ export {
   applyAggregations,
   applyPatch,
   applyQuery,
+  attentionTargetKey,
   boxSummary,
   branchesOf,
   calendarGroupKey,
@@ -7416,6 +7601,7 @@ export {
   compileFormula,
   compileMetric,
   computedFieldName,
+  createAttentionRegistry,
   createGroupingModel,
   createPropertyView,
   createQueryLinkService,
@@ -7451,17 +7637,21 @@ export {
   isGroupLinkValue,
   isGroupable,
   isGroupingTimeZone,
+  isJsonBucketId,
+  isJsonPath,
   isMeasurable,
   isMetricCycle,
   isNegativePredicate,
   isOrGroup,
   isOrOfAndsGroup,
+  isPropertyFieldLoaded,
   isPushdownFilter,
   isSelectable,
   isSortable,
   isWhereConjunction,
   isWhereGroup,
   itemPageFields,
+  jsonInspectionScopeKey,
   jsonPropertyViewStorage,
   loadSchema,
   localPropertyViewStorage,
@@ -7504,6 +7694,8 @@ export {
   opPairsForField,
   opsForField,
   parseHostQueryState,
+  parseJsonInspectionState,
+  parseJsonInspections,
   parseRelativeDuration,
   percentile,
   planMetricSeries,