@rocicorp/zero 0.23.2025101600 → 0.24.3000-canary.1

package/out/{chunk-O7W55FT4.js → chunk-VZOYWIRW.js}

@@ -27,4 +27,4 @@ var MarkIcon = (props) => /* @__PURE__ */ jsxs(
 export {
   MarkIcon
 };
-//# sourceMappingURL=chunk-O7W55FT4.js.map
+//# sourceMappingURL=chunk-VZOYWIRW.js.map

package/out/chunk-VZOYWIRW.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../zero-react/src/components/mark-icon.tsx"],
+  "sourcesContent": ["import type {FC, SVGProps} from 'react';\n\nexport const MarkIcon: FC<SVGProps<SVGSVGElement>> = props => (\n  <svg\n    width=\"18\"\n    height=\"18\"\n    viewBox=\"0 0 24 24\"\n    fill=\"none\"\n    xmlns=\"http://www.w3.org/2000/svg\"\n    {...props}\n  >\n    <title>Show Zero Inspector</title>\n    <path\n      fillRule=\"evenodd\"\n      clipRule=\"evenodd\"\n      d=\"M0.407235 15.1075C-0.661857 11.1041 0.374032 6.65546 3.51478 3.51471C8.20106 -1.17157 15.799 -1.17157 20.4854 3.51471C20.8969 3.92627 21.2723 4.36029 21.6115 4.81284L17.6063 8.81802H12.7576L16.7275 4.84814C13.3994 2.64322 8.87135 3.00687 5.9391 5.93909C4.24366 7.63455 3.40687 9.86362 3.42896 12.0857L0.407235 15.1075ZM18.0609 18.0609C15.1287 20.9931 10.6006 21.3568 7.27247 19.1519L11.2423 15.182H6.39356L2.38844 19.1872C2.72767 19.6397 3.10316 20.0737 3.51466 20.4853C8.20094 25.1716 15.799 25.1716 20.4852 20.4853C23.626 17.3445 24.6619 12.8959 23.5927 8.89255L20.5709 11.9143C20.593 14.1364 19.7564 16.3654 18.0609 18.0609Z\"\n      fill=\"currentColor\"\n    />\n  </svg>\n);\n"],
+  "mappings": ";AAGE,SAQE,KARF;AADK,IAAM,WAAwC,WACnD;AAAA,EAAC;AAAA;AAAA,IACC,OAAM;AAAA,IACN,QAAO;AAAA,IACP,SAAQ;AAAA,IACR,MAAK;AAAA,IACL,OAAM;AAAA,IACL,GAAG;AAAA,IAEJ;AAAA,0BAAC,WAAM,iCAAmB;AAAA,MAC1B;AAAA,QAAC;AAAA;AAAA,UACC,UAAS;AAAA,UACT,UAAS;AAAA,UACT,GAAE;AAAA,UACF,MAAK;AAAA;AAAA,MACP;AAAA;AAAA;AACF;",
+  "names": []
+}

package/out/chunk-ZZXMKAAG.js

@@ -0,0 +1,64 @@
+import {
+  SQLiteStore,
+  dropStore
+} from "./chunk-ECUMGQGC.js";
+
+// ../replicache/src/kv/expo-sqlite/store.ts
+import {
+  deleteDatabaseSync,
+  openDatabaseSync
+} from "expo-sqlite";
+function dropExpoSQLiteStore(name) {
+  return dropStore(name, (filename) => new ExpoSQLiteDatabase(filename));
+}
+function expoSQLiteStoreProvider(opts) {
+  return {
+    create: (name) => new SQLiteStore(name, (name2) => new ExpoSQLiteDatabase(name2), opts),
+    drop: dropExpoSQLiteStore
+  };
+}
+var ExpoSQLitePreparedStatement = class {
+  #statement;
+  constructor(statement) {
+    this.#statement = statement;
+  }
+  async firstValue(params) {
+    const result = await this.#statement.executeForRawResultAsync(params);
+    const row = await result.getFirstAsync();
+    return row === null ? void 0 : row[0];
+  }
+  async exec(params) {
+    await this.#statement.executeForRawResultAsync(params);
+  }
+};
+var ExpoSQLiteDatabase = class {
+  #db;
+  #filename;
+  #statements = /* @__PURE__ */ new Set();
+  constructor(filename) {
+    this.#filename = filename;
+    this.#db = openDatabaseSync(filename);
+  }
+  close() {
+    for (const stmt of this.#statements) {
+      stmt.finalizeSync();
+    }
+    this.#db.closeSync();
+  }
+  destroy() {
+    deleteDatabaseSync(this.#filename);
+  }
+  prepare(sql) {
+    const statement = this.#db.prepareSync(sql);
+    this.#statements.add(statement);
+    return new ExpoSQLitePreparedStatement(statement);
+  }
+  execSync(sql) {
+    this.#db.execSync(sql);
+  }
+};
+
+export {
+  expoSQLiteStoreProvider
+};
+//# sourceMappingURL=chunk-ZZXMKAAG.js.map

package/out/chunk-ZZXMKAAG.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../replicache/src/kv/expo-sqlite/store.ts"],
+  "sourcesContent": ["import {\n  deleteDatabaseSync,\n  openDatabaseSync,\n  type SQLiteDatabase as DB,\n  type SQLiteStatement,\n} from 'expo-sqlite';\nimport type {\n  PreparedStatement,\n  SQLiteDatabase,\n  SQLiteStoreOptions,\n} from '../sqlite-store.ts';\nimport {dropStore, SQLiteStore} from '../sqlite-store.ts';\nimport type {StoreProvider} from '../store.ts';\n\nexport type ExpoSQLiteStoreOptions = SQLiteStoreOptions;\n\nexport function dropExpoSQLiteStore(name: string): Promise<void> {\n  return dropStore(name, filename => new ExpoSQLiteDatabase(filename));\n}\n\n/**\n * Creates a StoreProvider for SQLite-based stores using expo-sqlite.\n * Supports shared connections between multiple store instances with the same name,\n * providing efficient resource utilization and proper transaction isolation.\n */\nexport function expoSQLiteStoreProvider(\n  opts?: ExpoSQLiteStoreOptions,\n): StoreProvider {\n  return {\n    create: name =>\n      new SQLiteStore(name, name => new ExpoSQLiteDatabase(name), opts),\n    drop: dropExpoSQLiteStore,\n  };\n}\n\nclass ExpoSQLitePreparedStatement implements PreparedStatement {\n  readonly #statement: SQLiteStatement;\n\n  constructor(statement: SQLiteStatement) {\n    this.#statement = statement;\n  }\n\n  async firstValue(params: string[]): Promise<string | undefined> {\n    const result = await this.#statement.executeForRawResultAsync(params);\n    const row = await result.getFirstAsync();\n    return row === null ? undefined : row[0];\n  }\n\n  async exec(params: string[]): Promise<void> {\n    await this.#statement.executeForRawResultAsync(params);\n  }\n}\n\nclass ExpoSQLiteDatabase implements SQLiteDatabase {\n  readonly #db: DB;\n  readonly #filename: string;\n  readonly #statements: Set<SQLiteStatement> = new Set();\n\n  constructor(filename: string) {\n    this.#filename = filename;\n    this.#db = openDatabaseSync(filename);\n  }\n\n  close(): void {\n    for (const stmt of this.#statements) {\n      stmt.finalizeSync();\n    }\n    this.#db.closeSync();\n  }\n\n  destroy(): void {\n    deleteDatabaseSync(this.#filename);\n  }\n\n  prepare(sql: string): PreparedStatement {\n    const statement = this.#db.prepareSync(sql);\n    this.#statements.add(statement);\n    return new ExpoSQLitePreparedStatement(statement);\n  }\n\n  execSync(sql: string): void {\n    this.#db.execSync(sql);\n  }\n}\n"],
+  "mappings": ";;;;;;AAAA;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AAWA,SAAS,oBAAoB,MAA6B;AAC/D,SAAO,UAAU,MAAM,cAAY,IAAI,mBAAmB,QAAQ,CAAC;AACrE;AAOO,SAAS,wBACd,MACe;AACf,SAAO;AAAA,IACL,QAAQ,UACN,IAAI,YAAY,MAAM,CAAAA,UAAQ,IAAI,mBAAmBA,KAAI,GAAG,IAAI;AAAA,IAClE,MAAM;AAAA,EACR;AACF;AAEA,IAAM,8BAAN,MAA+D;AAAA,EACpD;AAAA,EAET,YAAY,WAA4B;AACtC,SAAK,aAAa;AAAA,EACpB;AAAA,EAEA,MAAM,WAAW,QAA+C;AAC9D,UAAM,SAAS,MAAM,KAAK,WAAW,yBAAyB,MAAM;AACpE,UAAM,MAAM,MAAM,OAAO,cAAc;AACvC,WAAO,QAAQ,OAAO,SAAY,IAAI,CAAC;AAAA,EACzC;AAAA,EAEA,MAAM,KAAK,QAAiC;AAC1C,UAAM,KAAK,WAAW,yBAAyB,MAAM;AAAA,EACvD;AACF;AAEA,IAAM,qBAAN,MAAmD;AAAA,EACxC;AAAA,EACA;AAAA,EACA,cAAoC,oBAAI,IAAI;AAAA,EAErD,YAAY,UAAkB;AAC5B,SAAK,YAAY;AACjB,SAAK,MAAM,iBAAiB,QAAQ;AAAA,EACtC;AAAA,EAEA,QAAc;AACZ,eAAW,QAAQ,KAAK,aAAa;AACnC,WAAK,aAAa;AAAA,IACpB;AACA,SAAK,IAAI,UAAU;AAAA,EACrB;AAAA,EAEA,UAAgB;AACd,uBAAmB,KAAK,SAAS;AAAA,EACnC;AAAA,EAEA,QAAQ,KAAgC;AACtC,UAAM,YAAY,KAAK,IAAI,YAAY,GAAG;AAC1C,SAAK,YAAY,IAAI,SAAS;AAC9B,WAAO,IAAI,4BAA4B,SAAS;AAAA,EAClD;AAAA,EAEA,SAAS,KAAmB;AAC1B,SAAK,IAAI,SAAS,GAAG;AAAA,EACvB;AACF;",
+  "names": ["name"]
+}

package/out/expo-sqlite.js

@@ -0,0 +1,11 @@
+import {
+  expoSQLiteStoreProvider
+} from "./chunk-ZZXMKAAG.js";
+import "./chunk-ECUMGQGC.js";
+import "./chunk-ASRS2LFV.js";
+import "./chunk-EZM3XBAB.js";
+import "./chunk-424PT5DM.js";
+export {
+  expoSQLiteStoreProvider
+};
+//# sourceMappingURL=expo-sqlite.js.map

package/out/expo-sqlite.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/out/{inspector-YIRP3TTL.js → inspector-IU2HG74I.js}

@@ -1,6 +1,6 @@
 import {
   MarkIcon
-} from "./chunk-O7W55FT4.js";
+} from "./chunk-VZOYWIRW.js";
 import "./chunk-424PT5DM.js";
 
 // ../zero-react/src/components/inspector.tsx
@@ -40,4 +40,4 @@ function Inspector({ zero, onClose }) {
 export {
   Inspector as default
 };
-//# sourceMappingURL=inspector-YIRP3TTL.js.map
+//# sourceMappingURL=inspector-IU2HG74I.js.map

package/out/lazy-inspector-NCBESZMS.js

@@ -0,0 +1,574 @@
+import {
+  Client,
+  ENTITIES_KEY_PREFIX,
+  Latest,
+  SUBQ_PREFIX,
+  TDigest,
+  getClient,
+  getClientGroup,
+  getClients,
+  inspectAnalyzeQueryDownSchema,
+  inspectAuthenticatedDownSchema,
+  inspectMetricsDownSchema,
+  inspectQueriesDownSchema,
+  inspectVersionDownSchema,
+  mapValues,
+  must,
+  nanoid,
+  normalizeTTL,
+  readFromHash,
+  test,
+  valita_exports,
+  withRead
+} from "./chunk-VHLCXJ6Q.js";
+import {
+  assert,
+  unreachable
+} from "./chunk-EZM3XBAB.js";
+import "./chunk-424PT5DM.js";
+
+// ../zero-client/src/client/inspector/html-dialog-prompt.ts
+function canUseHTMLDialog() {
+  try {
+    if (typeof globalThis !== "undefined" && "__vitest_worker__" in globalThis) {
+      return false;
+    }
+    return typeof document !== "undefined" && typeof document.createElement === "function" && typeof HTMLDialogElement !== "undefined" && document.body !== null && // Make sure we can actually create a dialog element
+    document.createElement("dialog") instanceof HTMLDialogElement;
+  } catch {
+    return false;
+  }
+}
+function createHTMLPasswordPrompt(message) {
+  if (!canUseHTMLDialog()) {
+    return Promise.resolve(prompt(message));
+  }
+  return new Promise((resolve) => {
+    const reset = "all:revert;";
+    const w = "rgba(255,255,255,";
+    const white = w + "1)";
+    const whiteTransp = w + "0.4)";
+    const r1 = "0.25rem";
+    const font = `font-family:system-ui,sans-serif;color:${white};`;
+    const btnBase = `${reset}${font}cursor:pointer;font-size:1rem;font-weight:500;border:none;padding:0.4rem 0.75rem;border-radius:${r1};background:`;
+    const dialog = document.createElement("dialog");
+    dialog.style.cssText = `${reset}${font}background:rgba(0,0,0,0.95);padding:2rem;border:1px solid ${whiteTransp};border-radius:0.5rem;`;
+    dialog.addEventListener("keydown", (e) => {
+      e.stopPropagation();
+    });
+    dialog.oncancel = () => {
+      dialog.remove();
+      resolve(null);
+    };
+    const form = document.createElement("form");
+    form.method = "dialog";
+    form.style.cssText = `${reset}margin:0;`;
+    const messagePara = document.createElement("p");
+    messagePara.style.cssText = `${reset}${font}font-size:1.5rem;margin:0 0 1rem 0;`;
+    messagePara.append(message);
+    const passwordInput = document.createElement("input");
+    passwordInput.type = "password";
+    passwordInput.placeholder = "Admin password";
+    passwordInput.autocomplete = "current-password";
+    passwordInput.autofocus = true;
+    passwordInput.style.cssText = `${reset}${font}font-size:1rem;display:block;margin:0 0 1rem 0;padding:0.5rem;background:rgba(0,0,0,0.5);border:1px solid ${whiteTransp};border-radius:${r1};`;
+    const buttonDiv = document.createElement("div");
+    buttonDiv.style.cssText = reset;
+    const cancelBtn = document.createElement("button");
+    cancelBtn.type = "reset";
+    cancelBtn.append("Cancel");
+    cancelBtn.style.cssText = btnBase + w + "0.25);";
+    const okBtn = document.createElement("button");
+    okBtn.type = "submit";
+    okBtn.value = "ok";
+    okBtn.append("OK");
+    okBtn.style.cssText = btnBase + "rgba(19,106,235,1);margin-right:0.5rem;";
+    buttonDiv.append(okBtn, cancelBtn);
+    form.append(messagePara, passwordInput, buttonDiv);
+    dialog.append(form);
+    form.onreset = () => {
+      dialog.close();
+    };
+    dialog.onclose = () => {
+      if (dialog.returnValue === "ok") {
+        resolve(passwordInput.value || null);
+      } else {
+        resolve(null);
+      }
+      dialog.remove();
+    };
+    document.body.append(dialog);
+    dialog.showModal();
+  });
+}
+
+// ../ast-to-zql/src/ast-to-zql.ts
+function astToZQL(ast) {
+  let code = "";
+  if (ast.where) {
+    code += transformCondition(ast.where, ".where", /* @__PURE__ */ new Set());
+  }
+  if (ast.related && ast.related.length > 0) {
+    for (const related of ast.related) {
+      if (related.hidden) {
+        const nestedRelated = related.subquery.related?.[0];
+        if (nestedRelated) {
+          code += transformRelated(nestedRelated);
+        }
+      } else {
+        code += transformRelated(related);
+      }
+    }
+  }
+  if (ast.orderBy && ast.orderBy.length > 0) {
+    code += transformOrder(ast.orderBy);
+  }
+  if (ast.limit !== void 0) {
+    code += `.limit(${ast.limit})`;
+  }
+  if (ast.start) {
+    const { row, exclusive } = ast.start;
+    code += `.start(${JSON.stringify(row)}${exclusive ? "" : ", { inclusive: true }"})`;
+  }
+  return code;
+}
+function transformCondition(condition, prefix, args) {
+  switch (condition.type) {
+    case "simple":
+      return transformSimpleCondition(condition, prefix);
+    case "and":
+    case "or":
+      return transformLogicalCondition(condition, prefix, args);
+    case "correlatedSubquery":
+      return transformExistsCondition(condition, prefix, args);
+    default:
+      unreachable(condition);
+  }
+}
+function transformSimpleCondition(condition, prefix) {
+  const { left, op, right } = condition;
+  const leftCode = transformValuePosition(left);
+  const rightCode = transformValuePosition(right);
+  if (op === "=") {
+    return `${prefix}(${leftCode}, ${rightCode})`;
+  }
+  return `${prefix}(${leftCode}, '${op}', ${rightCode})`;
+}
+function transformLogicalCondition(condition, prefix, args) {
+  const { type, conditions } = condition;
+  if (conditions.length === 1) {
+    return transformCondition(conditions[0], prefix, args);
+  }
+  if (type === "and") {
+    const parts = conditions.map((c) => transformCondition(c, prefix, args));
+    if (prefix === ".where") {
+      return parts.join("");
+    }
+    args.add("and");
+    return "and(" + parts.join(", ") + ")";
+  }
+  args = /* @__PURE__ */ new Set();
+  const conditionsCode = conditions.map((c) => transformCondition(c, "cmp", args)).join(", ");
+  args.add("cmp");
+  args.add(type);
+  const argsCode = [...args].sort().join(", ");
+  return `.where(({${argsCode}}) => ${type}(${conditionsCode}))`;
+}
+function transformExistsCondition(condition, prefix, args) {
+  const { related, op } = condition;
+  const relationship = extractRelationshipName(related);
+  const nextSubquery = getNextExistsSubquery(related);
+  const hasSubQueryProps = nextSubquery.where || nextSubquery.related && nextSubquery.related.length > 0 || nextSubquery.orderBy || nextSubquery.limit;
+  if (op === "EXISTS") {
+    const flipped = condition.flip ? ", {flip: true}" : "";
+    if (!hasSubQueryProps) {
+      if (prefix === ".where") {
+        return `.whereExists('${relationship}'${flipped})`;
+      }
+      args.add("exists");
+      return `exists('${relationship}'${flipped})`;
+    }
+    if (prefix === ".where") {
+      return `.whereExists('${relationship}', q => q${astToZQL(nextSubquery)}${flipped})`;
+    }
+    prefix;
+    args.add("exists");
+    return `exists('${relationship}', q => q${astToZQL(nextSubquery)}${flipped})`;
+  }
+  op;
+  if (hasSubQueryProps) {
+    if (prefix === ".where") {
+      return `.where(({exists, not}) => not(exists('${relationship}', q => q${astToZQL(
+        nextSubquery
+      )})))`;
+    }
+    prefix;
+    args.add("not");
+    args.add("exists");
+    return `not(exists('${relationship}', q => q${astToZQL(nextSubquery)}))`;
+  }
+  if (prefix === ".where") {
+    return `.where(({exists, not}) => not(exists('${relationship}')))`;
+  }
+  args.add("not");
+  args.add("exists");
+  return `not(exists('${relationship}')))`;
+}
+function getNextExistsSubquery(related) {
+  if (related.subquery.where?.type === "correlatedSubquery" && related.subquery.where.related.subquery.alias?.includes(
+    SUBQ_PREFIX + "zhidden_"
+  )) {
+    return getNextExistsSubquery(related.subquery.where.related);
+  }
+  return related.subquery;
+}
+function extractRelationshipName(related) {
+  const alias = must(related.subquery.alias);
+  return alias.startsWith(SUBQ_PREFIX) ? alias.substring(SUBQ_PREFIX.length) : alias;
+}
+function transformRelated(related) {
+  const { alias } = related.subquery;
+  if (!alias) return "";
+  const relationship = alias;
+  let code = `.related('${relationship}'`;
+  if (related.subquery.where || related.subquery.related && related.subquery.related.length > 0 || related.subquery.orderBy || related.subquery.limit) {
+    code += ", q => q" + astToZQL(related.subquery);
+  }
+  code += ")";
+  return code;
+}
+function transformOrder(orderBy) {
+  let code = "";
+  for (const [field, direction] of orderBy) {
+    code += `.orderBy('${field}', '${direction}')`;
+  }
+  return code;
+}
+function transformValuePosition(value) {
+  switch (value.type) {
+    case "literal":
+      return transformLiteral(value);
+    case "column":
+      return `'${value.name}'`;
+    case "static":
+      return transformParameter(value);
+    default:
+      unreachable(value);
+  }
+}
+function transformLiteral(literal) {
+  if (literal.value === null) {
+    return "null";
+  }
+  if (Array.isArray(literal.value)) {
+    return JSON.stringify(literal.value);
+  }
+  if (typeof literal.value === "string") {
+    return `'${literal.value.replace(/'/g, "\\'")}'`;
+  }
+  return String(literal.value);
+}
+function transformParameter(param) {
+  const fieldStr = Array.isArray(param.field) ? `[${param.field.map((f) => `'${f}'`).join(", ")}]` : `'${param.field}'`;
+  return `authParam(${fieldStr})`;
+}
+
+// ../zero-client/src/client/inspector/query.ts
+var Query = class {
+  #socket;
+  name;
+  args;
+  got;
+  ttl;
+  inactivatedAt;
+  rowCount;
+  deleted;
+  id;
+  clientID;
+  metrics;
+  clientZQL;
+  serverZQL;
+  #serverAST;
+  hydrateClient;
+  hydrateServer;
+  hydrateTotal;
+  updateClientP50;
+  updateClientP95;
+  updateServerP50;
+  updateServerP95;
+  constructor(row, delegate, socket) {
+    this.#socket = socket;
+    const { ast, queryID, inactivatedAt } = row;
+    this.clientID = row.clientID;
+    this.id = queryID;
+    this.inactivatedAt = inactivatedAt === null ? null : new Date(inactivatedAt);
+    this.ttl = normalizeTTL(row.ttl);
+    this.name = row.name;
+    this.args = row.args;
+    this.got = row.got;
+    this.rowCount = row.rowCount;
+    this.deleted = row.deleted;
+    this.#serverAST = ast;
+    this.serverZQL = ast ? ast.table + astToZQL(ast) : null;
+    const clientAST = delegate.getAST(queryID);
+    this.clientZQL = clientAST ? clientAST.table + astToZQL(clientAST) : null;
+    const clientMetrics = delegate.getQueryMetrics(queryID);
+    const serverMetrics = row.metrics;
+    const merged = mergeMetrics(clientMetrics, serverMetrics);
+    this.metrics = merged;
+    const percentile = (name, percentile2) => {
+      if (!merged?.[name]) {
+        return null;
+      }
+      const n = merged[name].quantile(percentile2);
+      return Number.isNaN(n) ? null : n;
+    };
+    this.hydrateClient = percentile("query-materialization-client", 0.5);
+    this.hydrateServer = percentile("query-materialization-server", 0.5);
+    this.hydrateTotal = percentile("query-materialization-end-to-end", 0.5);
+    this.updateClientP50 = percentile("query-update-client", 0.5);
+    this.updateClientP95 = percentile("query-update-client", 0.95);
+    this.updateServerP50 = percentile("query-update-server", 0.5);
+    this.updateServerP95 = percentile("query-update-server", 0.95);
+  }
+  async analyze(options) {
+    assert(this.#serverAST, "No server AST available for this query");
+    return rpc(
+      await this.#socket(),
+      {
+        op: "analyze-query",
+        value: this.#serverAST,
+        options
+      },
+      inspectAnalyzeQueryDownSchema
+    );
+  }
+};
+
+// ../zero-client/src/client/inspector/lazy-inspector.ts
+async function rpc(socket, arg, downSchema) {
+  try {
+    return await rpcNoAuthTry(socket, arg, downSchema);
+  } catch (e) {
+    if (e instanceof UnauthenticatedError) {
+      const password = await createHTMLPasswordPrompt("Enter password:");
+      if (password) {
+        const authRes = await rpcNoAuthTry(
+          socket,
+          { op: "authenticate", value: password },
+          inspectAuthenticatedDownSchema
+        );
+        if (authRes) {
+          return rpcNoAuthTry(socket, arg, downSchema);
+        }
+      }
+      throw new Error("Authentication failed");
+    }
+    throw e;
+  }
+}
+function rpcNoAuthTry(socket, arg, downSchema) {
+  return new Promise((resolve, reject) => {
+    const id = nanoid();
+    const f = (ev) => {
+      const msg = JSON.parse(ev.data);
+      if (msg[0] === "inspect") {
+        const body = msg[1];
+        if (body.id !== id) {
+          return;
+        }
+        const res = test(body, downSchema);
+        if (res.ok) {
+          if (res.value.op === "error") {
+            reject(new Error(res.value.value));
+          } else {
+            resolve(res.value.value);
+          }
+        } else {
+          const authRes = test(body, inspectAuthenticatedDownSchema);
+          if (authRes.ok) {
+            assert(
+              authRes.value.value === false,
+              "Expected unauthenticated response"
+            );
+            reject(new UnauthenticatedError());
+          }
+          reject(res.error);
+        }
+        socket.removeEventListener("message", f);
+      }
+    };
+    socket.addEventListener("message", f);
+    socket.send(JSON.stringify(["inspect", { ...arg, id }]));
+  });
+}
+function mergeMetrics(clientMetrics, serverMetrics) {
+  return {
+    ...clientMetrics ?? newClientMetrics(),
+    ...serverMetrics ? convertServerMetrics(serverMetrics) : newServerMetrics()
+  };
+}
+function newClientMetrics() {
+  return {
+    "query-materialization-client": new TDigest(),
+    "query-materialization-end-to-end": new TDigest(),
+    "query-update-client": new TDigest()
+  };
+}
+function newServerMetrics() {
+  return {
+    "query-materialization-server": new TDigest(),
+    "query-update-server": new TDigest()
+  };
+}
+function convertServerMetrics(metrics) {
+  return mapValues(metrics, (v) => TDigest.fromJSON(v));
+}
+async function inspectorMetrics(delegate) {
+  const clientMetrics = delegate.metrics;
+  const serverMetricsJSON = await rpc(
+    await delegate.getSocket(),
+    { op: "metrics" },
+    inspectMetricsDownSchema
+  );
+  return mergeMetrics(clientMetrics, serverMetricsJSON);
+}
+function inspectorClients(delegate) {
+  return withDagRead(delegate, (dagRead) => clients(delegate, dagRead));
+}
+function inspectorClientsWithQueries(delegate) {
+  return withDagRead(
+    delegate,
+    (dagRead) => clientsWithQueries(delegate, dagRead)
+  );
+}
+async function withDagRead(delegate, f) {
+  const { rep } = delegate;
+  await rep.refresh();
+  await rep.persist();
+  return withRead(rep.perdag, f);
+}
+async function getBTree(dagRead, clientID) {
+  const client = await getClient(clientID, dagRead);
+  assert(client, `Client not found: ${clientID}`);
+  const { clientGroupID } = client;
+  const clientGroup = await getClientGroup(clientGroupID, dagRead);
+  assert(clientGroup, `Client group not found: ${clientGroupID}`);
+  const dbRead = await readFromHash(
+    clientGroup.headHash,
+    dagRead,
+    Latest
+  );
+  return dbRead.map;
+}
+async function clients(delegate, dagRead, predicate = () => true) {
+  const clients2 = await getClients(dagRead);
+  return [...clients2.entries()].filter(predicate).map(
+    ([clientID, { clientGroupID }]) => new Client(delegate, clientID, clientGroupID)
+  );
+}
+async function clientsWithQueries(delegate, dagRead, predicate = () => true) {
+  const allClients = await clients(delegate, dagRead, predicate);
+  const clientsWithQueries2 = [];
+  await Promise.all(
+    allClients.map(async (client) => {
+      const queries = await client.queries();
+      if (queries.length > 0) {
+        clientsWithQueries2.push(client);
+      }
+    })
+  );
+  return clientsWithQueries2;
+}
+async function clientGroupClients(delegate, clientGroupID) {
+  const id = await clientGroupID;
+  return withDagRead(
+    delegate,
+    (dagRead) => clients(delegate, dagRead, ([_, v]) => v.clientGroupID === id)
+  );
+}
+async function clientGroupClientsWithQueries(delegate, clientGroupID) {
+  const id = await clientGroupID;
+  return withDagRead(
+    delegate,
+    (dagRead) => clientsWithQueries(delegate, dagRead, ([_, v]) => v.clientGroupID === id)
+  );
+}
+async function clientGroupQueries(delegate) {
+  const rows = await rpc(
+    await delegate.getSocket(),
+    { op: "queries" },
+    inspectQueriesDownSchema
+  );
+  return rows.map((row) => new Query(row, delegate, delegate.getSocket));
+}
+function clientMap(delegate, clientID) {
+  return withDagRead(delegate, async (dagRead) => {
+    const tree = await getBTree(dagRead, clientID);
+    const map = /* @__PURE__ */ new Map();
+    for await (const [key, value] of tree.scan("")) {
+      map.set(key, value);
+    }
+    return map;
+  });
+}
+function clientRows(delegate, clientID, tableName) {
+  return withDagRead(delegate, async (dagRead) => {
+    const prefix = ENTITIES_KEY_PREFIX + tableName + "/";
+    const tree = await getBTree(dagRead, clientID);
+    const rows = [];
+    for await (const [key, value] of tree.scan(prefix)) {
+      if (!key.startsWith(prefix)) {
+        break;
+      }
+      rows.push(value);
+    }
+    return rows;
+  });
+}
+async function serverVersion(delegate) {
+  return rpc(
+    await delegate.getSocket(),
+    { op: "version" },
+    inspectVersionDownSchema
+  );
+}
+async function clientQueries(delegate, clientID) {
+  const rows = await rpc(
+    await delegate.getSocket(),
+    { op: "queries", clientID },
+    inspectQueriesDownSchema
+  );
+  return rows.map((row) => new Query(row, delegate, delegate.getSocket));
+}
+async function analyzeQuery(delegate, query, options) {
+  const { customQueryID } = query;
+  const queryParameters = customQueryID ? { name: customQueryID.name, args: customQueryID.args } : { ast: query.ast };
+  return rpc(
+    await delegate.getSocket(),
+    {
+      op: "analyze-query",
+      ...queryParameters,
+      options
+    },
+    inspectAnalyzeQueryDownSchema
+  );
+}
+var UnauthenticatedError = class extends Error {
+};
+export {
+  analyzeQuery,
+  clientGroupClients,
+  clientGroupClientsWithQueries,
+  clientGroupQueries,
+  clientMap,
+  clientQueries,
+  clientRows,
+  inspectorClients,
+  inspectorClientsWithQueries,
+  inspectorMetrics,
+  mergeMetrics,
+  rpc,
+  serverVersion
+};
+//# sourceMappingURL=lazy-inspector-NCBESZMS.js.map