@lupinum/better-convex-nuxt 0.8.0-beta.40

package/dist/runtime/convex-auth/user-projection.js

@@ -0,0 +1,128 @@
+function resolveAuthIdField(field) {
+  const resolved = field ?? "authId";
+  const startsWithReservedPrefix = resolved.startsWith("$") || resolved.startsWith("_");
+  let containsInvalidCharacter = false;
+  for (let index = 0; index < resolved.length && index <= 1024; index += 1) {
+    const code = resolved.charCodeAt(index);
+    if (code < 32 || code >= 127) {
+      containsInvalidCharacter = true;
+      break;
+    }
+  }
+  if (resolved.length === 0 || resolved.length > 1024 || startsWithReservedPrefix || containsInvalidCharacter || resolved.includes(".") || resolved === "prototype" || resolved === "constructor") {
+    throw new TypeError(
+      "[better-convex-nuxt] authIdField must be a valid top-level Convex application field"
+    );
+  }
+  return resolved;
+}
+function withCanonicalAuthId(value, authIdField, authUserId) {
+  return { ...value, [authIdField]: authUserId };
+}
+async function findExistingByAuthId(ctx, lookup, authUserId) {
+  const query = ctx.db.query(lookup.table);
+  return await query.withIndex(
+    lookup.index,
+    (q) => q.eq(lookup.authIdField, authUserId)
+  ).collect();
+}
+async function deleteDuplicateRows(ctx, existing) {
+  for (const duplicate of existing.slice(1)) {
+    await ctx.db.delete(duplicate._id);
+  }
+}
+export function createUserProjectionTriggers(options) {
+  const lookup = Object.freeze({
+    table: options.table,
+    index: options.index,
+    authIdField: resolveAuthIdField(options.authIdField)
+  });
+  return {
+    user: {
+      onCreate: async (ctx, user) => {
+        const now = Date.now();
+        const existing = await findExistingByAuthId(ctx, lookup, user.id);
+        if (existing.length > 0) {
+          await deleteDuplicateRows(ctx, existing);
+          return;
+        }
+        const doc = await options.createDoc({ ctx, user, now });
+        await ctx.db.insert(options.table, withCanonicalAuthId(doc, lookup.authIdField, user.id));
+      },
+      /**
+       * Patches the projected row for a Better Auth user update.
+       *
+       * If `onUpdate` fires before the corresponding `onCreate` has run
+       * for this user (e.g. out-of-order trigger delivery, or a webhook race),
+       * `findExistingByAuthId` finds nothing and this silently no-ops — the
+       * update is dropped rather than queued or retried. The row is created
+       * later by `onCreate`, but using `createDoc`'s snapshot at that later
+       * time, not the fields this update carried. If your projection needs
+       * updates to survive arriving before creation, either make `createDoc`
+       * derive from the latest known user state (not just the `onCreate`
+       * event's payload) or run `rebuild()` periodically to reconcile drift.
+       */
+      onUpdate: async (ctx, user, previousUser) => {
+        const existing = await findExistingByAuthId(ctx, lookup, user.id);
+        const [retained] = existing;
+        if (!retained) return;
+        await deleteDuplicateRows(ctx, existing);
+        if (!options.patchDoc) return;
+        const patch = await options.patchDoc({
+          ctx,
+          user,
+          previousUser,
+          existing: retained,
+          now: Date.now()
+        });
+        if (!patch || Object.keys(patch).length === 0) return;
+        await ctx.db.patch(retained._id, withCanonicalAuthId(patch, lookup.authIdField, user.id));
+      },
+      onDelete: async (ctx, user) => {
+        const existing = await findExistingByAuthId(ctx, lookup, user.id);
+        for (const row of existing) {
+          await ctx.db.delete(row._id);
+        }
+      },
+      rebuild: async (ctx, users) => {
+        const result = {
+          inserted: 0,
+          patched: 0,
+          skipped: 0
+        };
+        for (const user of users) {
+          const now = Date.now();
+          const existing = await findExistingByAuthId(ctx, lookup, user.id);
+          const [retained] = existing;
+          if (!retained) {
+            const doc = await options.createDoc({ ctx, user, now });
+            await ctx.db.insert(
+              options.table,
+              withCanonicalAuthId(doc, lookup.authIdField, user.id)
+            );
+            result.inserted += 1;
+            continue;
+          }
+          await deleteDuplicateRows(ctx, existing);
+          if (!options.rebuildDoc) {
+            result.skipped += 1;
+            continue;
+          }
+          const patch = await options.rebuildDoc({
+            ctx,
+            user,
+            existing: retained,
+            now
+          });
+          if (!patch || Object.keys(patch).length === 0) {
+            result.skipped += 1;
+            continue;
+          }
+          await ctx.db.patch(retained._id, withCanonicalAuthId(patch, lookup.authIdField, user.id));
+          result.patched += 1;
+        }
+        return result;
+      }
+    }
+  };
+}

package/dist/runtime/devtools/auth-proxy-registry.d.ts

@@ -0,0 +1,4 @@
+import type { AuthProxyRequest, AuthProxyStats } from './types.js';
+export declare function recordAuthProxyRequest(request: AuthProxyRequest): Promise<void>;
+export declare function getAuthProxyStats(): Promise<AuthProxyStats>;
+export declare function clearAuthProxyStats(): Promise<void>;

package/dist/runtime/devtools/auth-proxy-registry.js

@@ -0,0 +1,47 @@
+const MAX_REQUESTS = 20;
+const STORAGE_NAMESPACE = "devtools:convex:auth-proxy";
+const STORAGE_KEY = "requests";
+async function getStorage() {
+  const { useStorage } = await import("nitropack/runtime");
+  return useStorage(STORAGE_NAMESPACE);
+}
+async function getRequests() {
+  const storage = await getStorage();
+  const requests = await storage.getItem(STORAGE_KEY);
+  return Array.isArray(requests) ? requests : [];
+}
+async function setRequests(requests) {
+  const storage = await getStorage();
+  await storage.setItem(STORAGE_KEY, requests);
+}
+export async function recordAuthProxyRequest(request) {
+  const requests = await getRequests();
+  requests.unshift({
+    id: request.id,
+    path: request.path,
+    method: request.method,
+    timestamp: request.timestamp,
+    ...request.status === void 0 ? {} : { status: request.status },
+    ...request.duration === void 0 ? {} : { duration: request.duration },
+    ...request.success === void 0 ? {} : { success: request.success }
+  });
+  if (requests.length > MAX_REQUESTS) {
+    requests.length = MAX_REQUESTS;
+  }
+  await setRequests(requests);
+}
+export async function getAuthProxyStats() {
+  const requests = await getRequests();
+  const successful = requests.filter((r) => r.success);
+  const durations = successful.filter((r) => r.duration !== void 0).map((r) => r.duration);
+  return {
+    totalRequests: requests.length,
+    successCount: successful.length,
+    errorCount: requests.filter((r) => !r.success).length,
+    avgDuration: durations.length > 0 ? Math.round(durations.reduce((a, b) => a + b, 0) / durations.length) : 0,
+    recentRequests: [...requests]
+  };
+}
+export async function clearAuthProxyStats() {
+  await setRequests([]);
+}

package/dist/runtime/devtools/bridge-setup.d.ts

@@ -0,0 +1,21 @@
+/**
+ * DevTools bridge setup for the Nuxt DevTools integration.
+ *
+ * This module sets up the communication bridge between the main window
+ * and the DevTools iframe using BroadcastChannel.
+ */
+import type { Ref } from 'vue';
+import type { DevtoolsSink } from './sink.js';
+import type { AuthWaterfall, ConnectionState } from './types.js';
+/**
+ * Setup the DevTools bridge on the window object.
+ * Only called in dev mode from plugin.client.ts.
+ *
+ * @param sink - Per-app bounded diagnostics store
+ * @param convexToken - Ref to the current auth token
+ * @param convexUser - Ref to the current user data
+ * @param convexAuthWaterfall - Ref to the SSR auth waterfall timing data
+ * @param readConnectionState - Safe projection of the active Vue runtime connection
+ * @param providedInstanceId - Stable application identifier used for explicit UI selection
+ */
+export declare function setupDevToolsBridge(sink: DevtoolsSink, convexToken: Ref<string | null>, convexUser: Ref<unknown>, convexAuthWaterfall: Ref<AuthWaterfall | null>, readConnectionState: () => ConnectionState, providedInstanceId?: string): Promise<() => void>;

package/dist/runtime/devtools/bridge-setup.js

@@ -0,0 +1,165 @@
+import { toRaw } from "vue";
+import { decodeJwtPayload } from "../utils/convex-shared.js";
+import { createAppDevtoolsTransport, cloneDevtoolsPayload } from "./transport.js";
+export async function setupDevToolsBridge(sink, convexToken, convexUser, convexAuthWaterfall, readConnectionState, providedInstanceId) {
+  const decodeJWT = (token) => {
+    return decodeJwtPayload(token);
+  };
+  const bridge = {
+    version: "1.1.0",
+    getQueries: () => sink.getQueries(),
+    getQueryDetail: (id) => sink.getQuery(id),
+    subscribeToQueries: (callback) => sink.subscribeToQueries(callback),
+    getMutations: () => sink.getMutations(),
+    subscribeToMutations: (callback) => sink.subscribeToMutations(callback),
+    getAuthState: () => {
+      const rawUser = toRaw(convexUser.value);
+      const hasToken = !!convexToken.value;
+      const hasUser = !!(rawUser && typeof rawUser === "object" && (rawUser.id || rawUser.email));
+      const plainUser = hasUser ? cloneDevtoolsPayload(rawUser) : null;
+      return {
+        isAuthenticated: !!(hasToken && hasUser),
+        isPending: false,
+        // Could be enhanced to track pending state
+        user: plainUser,
+        tokenStatus: hasToken ? "valid" : "none"
+      };
+    },
+    getEnhancedAuthState: () => {
+      const baseState = bridge.getAuthState();
+      const token = convexToken.value;
+      if (!token) {
+        return {
+          ...baseState,
+          claims: void 0,
+          issuedAt: void 0,
+          expiresAt: void 0,
+          expiresInSeconds: void 0
+        };
+      }
+      const claims = decodeJWT(token);
+      const now = Math.floor(Date.now() / 1e3);
+      const expiresAt = claims?.exp;
+      const expiresInSeconds = expiresAt ? Math.max(0, expiresAt - now) : void 0;
+      return {
+        ...baseState,
+        claims: claims ?? void 0,
+        issuedAt: claims?.iat ? claims.iat * 1e3 : void 0,
+        expiresAt: expiresAt ? expiresAt * 1e3 : void 0,
+        expiresInSeconds
+      };
+    },
+    getConnectionState: readConnectionState,
+    getAuthWaterfall: () => {
+      const waterfall = convexAuthWaterfall.value;
+      if (!waterfall) return null;
+      return cloneDevtoolsPayload(toRaw(waterfall));
+    },
+    getAuthProxyStats: async () => {
+      try {
+        const response = await fetch("/__convex_devtools__/proxy-stats");
+        if (!response.ok) return null;
+        return await response.json();
+      } catch {
+        return null;
+      }
+    }
+  };
+  const instanceId = providedInstanceId ?? Math.random().toString(36).slice(2, 10);
+  const transport = createAppDevtoolsTransport("convex-devtools");
+  const onMessage = (event) => {
+    const data = event.data;
+    if (!data || typeof data !== "object") return;
+    const message = data;
+    if (message.type === "CONVEX_DEVTOOLS_INIT") {
+      transport.postMessage({
+        type: "CONVEX_DEVTOOLS_READY",
+        instanceId,
+        transport: transport.kind
+      });
+    } else if (message.type === "CONVEX_DEVTOOLS_REQUEST") {
+      if (message.instanceId && message.instanceId !== instanceId) {
+        return;
+      }
+      const { id, method, args } = message;
+      if (typeof id !== "number" || typeof method !== "string") {
+        return;
+      }
+      try {
+        const bridgeMethod = bridge[method];
+        if (typeof bridgeMethod === "function") {
+          Promise.resolve(bridgeMethod(...args || [])).then((result) => {
+            transport.postMessage({
+              type: "CONVEX_DEVTOOLS_RESPONSE",
+              id,
+              result,
+              instanceId,
+              transport: transport.kind
+            });
+          }).catch((err) => {
+            transport.postMessage({
+              type: "CONVEX_DEVTOOLS_RESPONSE",
+              id,
+              error: err instanceof Error ? err.message : String(err),
+              instanceId,
+              transport: transport.kind
+            });
+          });
+        } else if (bridgeMethod !== void 0) {
+          transport.postMessage({
+            type: "CONVEX_DEVTOOLS_RESPONSE",
+            id,
+            result: bridgeMethod,
+            instanceId,
+            transport: transport.kind
+          });
+        } else {
+          transport.postMessage({
+            type: "CONVEX_DEVTOOLS_RESPONSE",
+            id,
+            error: `Unknown method: ${method}`,
+            instanceId,
+            transport: transport.kind
+          });
+        }
+      } catch (err) {
+        transport.postMessage({
+          type: "CONVEX_DEVTOOLS_RESPONSE",
+          id,
+          error: err instanceof Error ? err.message : String(err),
+          instanceId,
+          transport: transport.kind
+        });
+      }
+    }
+  };
+  transport.addEventListener("message", onMessage);
+  const unsubscribeMutations = sink.subscribeToMutations((mutations) => {
+    transport.postMessage({
+      type: "CONVEX_DEVTOOLS_MUTATIONS",
+      mutations,
+      instanceId,
+      transport: transport.kind
+    });
+  });
+  const unsubscribeQueries = sink.subscribeToQueries((queries) => {
+    transport.postMessage({
+      type: "CONVEX_DEVTOOLS_QUERIES",
+      queries,
+      instanceId,
+      transport: transport.kind
+    });
+  });
+  let disposed = false;
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    unsubscribeMutations();
+    unsubscribeQueries();
+    transport.removeEventListener("message", onMessage);
+    transport.close();
+  };
+  const hot = import.meta.hot;
+  hot?.dispose(dispose);
+  return dispose;
+}

package/dist/runtime/devtools/path-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveDevtoolsFilePath(outputDir: string, pathname: string): string;
+export declare function isPathInsideDirectory(rootDir: string, filePath: string): boolean;

package/dist/runtime/devtools/path-utils.js

@@ -0,0 +1,12 @@
+import { join, relative, resolve, sep } from "node:path";
+export function resolveDevtoolsFilePath(outputDir, pathname) {
+  const outputDirResolved = resolve(outputDir);
+  return resolve(join(outputDirResolved, pathname));
+}
+export function isPathInsideDirectory(rootDir, filePath) {
+  const rootResolved = resolve(rootDir);
+  const fileResolved = resolve(filePath);
+  const rel = relative(rootResolved, fileResolved);
+  if (!rel) return false;
+  return !rel.startsWith("..") && !rel.includes(`${sep}..`);
+}

package/dist/runtime/devtools/server.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | NonSharedBuffer>>;
+export default _default;

package/dist/runtime/devtools/server.js

@@ -0,0 +1,108 @@
+import { readFileSync, existsSync } from "node:fs";
+import { defineEventHandler, setHeader, getRequestURL, createError } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { getAuthProxyStats, clearAuthProxyStats } from "./auth-proxy-registry.js";
+import { isPathInsideDirectory, resolveDevtoolsFilePath } from "./path-utils.js";
+const mimeTypes = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".mjs": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+function getMimeType(path) {
+  const ext = path.substring(path.lastIndexOf("."));
+  return mimeTypes[ext] || "application/octet-stream";
+}
+export default defineEventHandler(async (event) => {
+  if (!import.meta.dev) {
+    throw createError({ statusCode: 404, statusMessage: "Not Found" });
+  }
+  const config = useRuntimeConfig();
+  const outputDir = typeof config.convexDevtoolsPath === "string" ? config.convexDevtoolsPath : void 0;
+  const url = getRequestURL(event);
+  let pathname = url.pathname.replace("/__convex_devtools__", "") || "/";
+  if (pathname === "/proxy-stats") {
+    setHeader(event, "Content-Type", "application/json");
+    setHeader(event, "Cache-Control", "no-cache");
+    return JSON.stringify(await getAuthProxyStats());
+  }
+  if (pathname === "/proxy-stats/clear" && event.method === "POST") {
+    await clearAuthProxyStats();
+    setHeader(event, "Content-Type", "application/json");
+    return JSON.stringify({ success: true });
+  }
+  if (pathname === "/" || pathname === "") {
+    pathname = "/index.html";
+  }
+  if (!outputDir || !existsSync(outputDir)) {
+    if (pathname === "/index.html") {
+      setHeader(event, "Content-Type", "text/html");
+      return getFallbackHtml();
+    }
+    throw createError({ statusCode: 404, statusMessage: "Not Found" });
+  }
+  const filePath = resolveDevtoolsFilePath(outputDir, pathname);
+  if (!isPathInsideDirectory(outputDir, filePath)) {
+    throw createError({ statusCode: 403, statusMessage: "Forbidden" });
+  }
+  if (!existsSync(filePath)) {
+    if (pathname === "/index.html") {
+      setHeader(event, "Content-Type", "text/html");
+      return getFallbackHtml();
+    }
+    throw createError({ statusCode: 404, statusMessage: "Not Found" });
+  }
+  const content = readFileSync(filePath);
+  setHeader(event, "Content-Type", getMimeType(pathname));
+  setHeader(event, "Cache-Control", "no-cache");
+  return content;
+});
+function getFallbackHtml() {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Convex DevTools</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+      background: #1e1e1e;
+      color: #cccccc;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      height: 100vh;
+      margin: 0;
+    }
+    .message {
+      text-align: center;
+      padding: 40px;
+    }
+    .message h1 {
+      color: #ee8944;
+      margin-bottom: 16px;
+    }
+    code {
+      background: #252526;
+      padding: 4px 8px;
+      border-radius: 4px;
+      font-size: 13px;
+    }
+  </style>
+</head>
+<body>
+  <div class="message">
+    <h1>DevTools Not Built</h1>
+    <p>The DevTools UI needs to be built first.</p>
+    <p style="margin-top: 16px;">Run: <code>pnpm run build:devtools</code></p>
+  </div>
+</body>
+</html>`;
+}

package/dist/runtime/devtools/setup-client.d.ts

@@ -0,0 +1,16 @@
+import type { Ref } from 'vue';
+import type { ConvexRuntimeContext } from '../runtime-context.js';
+import type { Logger } from '../utils/logger.js';
+import type { AuthWaterfall } from './types.js';
+interface NuxtDevtoolsClientInput {
+    runtime: ConvexRuntimeContext;
+    token: Ref<string | null>;
+    user: Ref<unknown>;
+    waterfall: Ref<AuthWaterfall | null>;
+    instanceId: string;
+    logger: Logger;
+    onDispose(dispose: () => void): void;
+}
+/** Install Nuxt's diagnostics adapter without exposing the Vue runtime's raw client or credentials. */
+export declare function setupNuxtDevtoolsClient(input: NuxtDevtoolsClientInput): void;
+export {};

package/dist/runtime/devtools/setup-client.js

@@ -0,0 +1,43 @@
+function readConnection(runtime) {
+  const connection = runtime.attachment.connection?.snapshot();
+  if (!connection) {
+    return {
+      isConnected: false,
+      hasEverConnected: false,
+      connectionRetries: 0,
+      inflightRequests: 0
+    };
+  }
+  const explicitInflight = connection.inflightMutations + connection.inflightActions;
+  return {
+    isConnected: connection.isWebSocketConnected,
+    hasEverConnected: connection.hasEverConnected,
+    connectionRetries: connection.connectionRetries,
+    inflightRequests: explicitInflight > 0 ? explicitInflight : Number(connection.hasInflightRequests)
+  };
+}
+export function setupNuxtDevtoolsClient(input) {
+  void Promise.all([import("./bridge-setup"), import("./sink")]).then(async ([{ setupDevToolsBridge }, { createDevtoolsSink }]) => {
+    const sink = createDevtoolsSink();
+    const detachSink = input.runtime.attachDevtoolsSink(sink);
+    if (!detachSink) return;
+    let disposeBridge;
+    try {
+      disposeBridge = await setupDevToolsBridge(
+        sink,
+        input.token,
+        input.user,
+        input.waterfall,
+        () => readConnection(input.runtime),
+        input.instanceId
+      );
+    } catch (error) {
+      detachSink();
+      throw error;
+    }
+    input.onDispose(() => {
+      disposeBridge();
+      detachSink();
+    });
+  }).catch((error) => input.logger.debug("DevTools bridge setup failed", error));
+}

package/dist/runtime/devtools/sink.d.ts

@@ -0,0 +1,18 @@
+import type { MutationEntry, QueryRegistryEntry } from './types.js';
+type QuerySubscriber = (entries: QueryRegistryEntry[]) => void;
+type MutationSubscriber = (entries: MutationEntry[]) => void;
+export interface DevtoolsSink {
+    getQueries(): QueryRegistryEntry[];
+    getQuery(id: string): QueryRegistryEntry | undefined;
+    upsertQuery(entry: Omit<QueryRegistryEntry, 'lastUpdated'>): void;
+    removeQuery(id: string): void;
+    subscribeToQueries(callback: QuerySubscriber): () => void;
+    registerMutation(entry: Omit<MutationEntry, 'id'>): string;
+    updateMutation(id: string, update: Partial<Pick<MutationEntry, 'state' | 'result' | 'error' | 'settledAt' | 'duration'>>): void;
+    getMutations(): MutationEntry[];
+    subscribeToMutations(callback: MutationSubscriber): () => void;
+    clearIdentityOwned(): void;
+    dispose(): void;
+}
+export declare function createDevtoolsSink(): DevtoolsSink;
+export {};

package/dist/runtime/devtools/sink.js

@@ -0,0 +1,110 @@
+import { sanitizeDiagnosticValue } from "../utils/sanitize-diagnostic.js";
+const MAX_MUTATIONS = 50;
+const MAX_QUERIES = 200;
+function createId() {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) return crypto.randomUUID();
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+}
+export function createDevtoolsSink() {
+  const queries = /* @__PURE__ */ new Map();
+  const mutations = /* @__PURE__ */ new Map();
+  const querySubscribers = /* @__PURE__ */ new Set();
+  const mutationSubscribers = /* @__PURE__ */ new Set();
+  let disposed = false;
+  const cloneEntry = (entry) => sanitizeDiagnosticValue(entry);
+  const getQueries = () => [...queries.values()].map(cloneEntry);
+  const getMutations = () => [...mutations.values()].sort((left, right) => right.startedAt - left.startedAt).map(cloneEntry);
+  const notifyQueries = () => {
+    for (const subscriber of querySubscribers) {
+      try {
+        subscriber(getQueries());
+      } catch {
+      }
+    }
+  };
+  const notifyMutations = () => {
+    for (const subscriber of mutationSubscribers) {
+      try {
+        subscriber(getMutations());
+      } catch {
+      }
+    }
+  };
+  return {
+    getQueries,
+    getQuery: (id) => {
+      const entry = queries.get(id);
+      return entry ? cloneEntry(entry) : void 0;
+    },
+    upsertQuery(entry) {
+      if (disposed) return;
+      queries.delete(entry.id);
+      queries.set(entry.id, {
+        ...entry,
+        args: sanitizeDiagnosticValue(entry.args),
+        data: sanitizeDiagnosticValue(entry.data),
+        error: entry.error === void 0 ? void 0 : String(sanitizeDiagnosticValue(entry.error)),
+        lastUpdated: Date.now()
+      });
+      while (queries.size > MAX_QUERIES) queries.delete(queries.keys().next().value);
+      notifyQueries();
+    },
+    removeQuery(id) {
+      if (queries.delete(id)) notifyQueries();
+    },
+    subscribeToQueries(callback) {
+      if (disposed) return () => {
+      };
+      querySubscribers.add(callback);
+      callback(getQueries());
+      return () => querySubscribers.delete(callback);
+    },
+    registerMutation(entry) {
+      if (disposed) return "";
+      const id = createId();
+      mutations.set(id, {
+        ...entry,
+        id,
+        args: sanitizeDiagnosticValue(entry.args)
+      });
+      while (mutations.size > MAX_MUTATIONS) mutations.delete(mutations.keys().next().value);
+      notifyMutations();
+      return id;
+    },
+    updateMutation(id, update) {
+      if (disposed) return;
+      const existing = mutations.get(id);
+      if (!existing) return;
+      mutations.set(id, {
+        ...existing,
+        ...update,
+        ...update.result === void 0 ? {} : { result: sanitizeDiagnosticValue(update.result) },
+        ...update.error === void 0 ? {} : { error: String(sanitizeDiagnosticValue(update.error)) }
+      });
+      notifyMutations();
+    },
+    getMutations,
+    subscribeToMutations(callback) {
+      if (disposed) return () => {
+      };
+      mutationSubscribers.add(callback);
+      callback(getMutations());
+      return () => mutationSubscribers.delete(callback);
+    },
+    clearIdentityOwned() {
+      if (disposed) return;
+      queries.clear();
+      mutations.clear();
+      notifyQueries();
+      notifyMutations();
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      queries.clear();
+      mutations.clear();
+      querySubscribers.clear();
+      mutationSubscribers.clear();
+    }
+  };
+}