akanjs 3.1.0-rc.25 → 3.1.0-rc.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.1.0-rc.25",
+  "version": "3.1.0-rc.26",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/service/predefinedAdaptor/database.adaptor.ts

@@ -5,7 +5,7 @@ import path from "node:path";
 import type { PromiseOrObject } from "akanjs/base";
 import type { ConstantModel } from "akanjs/constant";
 import type { DatabaseModel, DocumentSchema, SchemaOf } from "akanjs/document";
-import type { Sql } from "postgres";
+import type { ReservedSql, Sql } from "postgres";
 import { adapt } from "../adapt";
 import { ScheduleAdaptorRole } from "./role.adaptor";
 import {
@@ -185,6 +185,16 @@ export class SqliteDatabase
       .run(key, value, Date.now());
   }
 
+  listMeta(prefix: string) {
+    return this.#db
+      .query(`SELECT "key", "value" FROM "_akan_meta" WHERE substr("key", 1, ?) = ?`)
+      .all(prefix.length, prefix) as { key: string; value: string }[];
+  }
+
+  async deleteMeta(key: string) {
+    await this.#client.prepare(`DELETE FROM "_akan_meta" WHERE "key" = ?`).run(key);
+  }
+
   async transaction<T>(fn: () => PromiseOrObject<T>): Promise<T> {
     const active = this.#transaction.getStore();
     if (active) return await fn();
@@ -438,6 +448,16 @@ export class PostgresDatabase
       .run(key, value, Date.now());
   }
 
+  async listMeta(prefix: string) {
+    return await this.getConnection()
+      .prepare(`SELECT "key", "value" FROM "_akan_meta" WHERE substr("key", 1, $1) = $2`)
+      .all<{ key: string; value: string }>(prefix.length, prefix);
+  }
+
+  async deleteMeta(key: string) {
+    await this.getConnection().prepare(`DELETE FROM "_akan_meta" WHERE "key" = $1`).run(key);
+  }
+
   async transaction<T>(fn: () => PromiseOrObject<T>): Promise<T> {
     const active = this.#transaction.getStore();
     if (active) return await fn();
@@ -491,35 +511,47 @@ export class PostgresDatabase
   }
 
   async buildIndexConcurrently({ name, next, create, replace }: ConcurrentIndexBuild) {
+    await this.#underIndexLock(name, async (reserved) => {
+      const valid = async (index: string) =>
+        (
+          await reserved.unsafe(`SELECT indisvalid AS "valid" FROM pg_index WHERE indexrelid = to_regclass($1)`, [
+            quoteIdent(index),
+          ])
+        ).at(0)?.valid as boolean | undefined;
+      if (!replace) {
+        const state = await valid(name);
+        if (state) return;
+        if (state === false) await reserved.unsafe(`DROP INDEX CONCURRENTLY IF EXISTS ${quoteIdent(name)}`);
+        await reserved.unsafe(create(name));
+        return;
+      }
+      
+      await reserved.unsafe(`DROP INDEX CONCURRENTLY IF EXISTS ${quoteIdent(next)}`);
+      try {
+        await reserved.unsafe(create(next));
+      } catch (error) {
+        await reserved.unsafe(`DROP INDEX CONCURRENTLY IF EXISTS ${quoteIdent(next)}`);
+        throw error;
+      }
+      await reserved.unsafe(
+        `DROP INDEX IF EXISTS ${quoteIdent(name)}; ALTER INDEX ${quoteIdent(next)} RENAME TO ${quoteIdent(name)}`,
+      );
+    });
+  }
+
+  async dropIndexConcurrently(name: string) {
+    await this.#underIndexLock(name, async (reserved) => {
+      await reserved.unsafe(`DROP INDEX CONCURRENTLY IF EXISTS ${quoteIdent(name)}`);
+    });
+  }
+
+  async #underIndexLock(name: string, fn: (reserved: ReservedSql) => Promise<void>) {
     const reserved = await this.#sql.reserve();
     const key = `akan:index:${name}`;
-    const valid = async (index: string) =>
-      (
-        await reserved.unsafe(`SELECT indisvalid AS "valid" FROM pg_index WHERE indexrelid = to_regclass($1)`, [
-          quoteIdent(index),
-        ])
-      ).at(0)?.valid as boolean | undefined;
     try {
       await reserved.unsafe(`SELECT pg_advisory_lock(hashtext(current_schema() || $1))`, [key]);
       try {
-        if (!replace) {
-          const state = await valid(name);
-          if (state) return;
-          if (state === false) await reserved.unsafe(`DROP INDEX CONCURRENTLY IF EXISTS ${quoteIdent(name)}`);
-          await reserved.unsafe(create(name));
-          return;
-        }
-        
-        await reserved.unsafe(`DROP INDEX CONCURRENTLY IF EXISTS ${quoteIdent(next)}`);
-        try {
-          await reserved.unsafe(create(next));
-        } catch (error) {
-          await reserved.unsafe(`DROP INDEX CONCURRENTLY IF EXISTS ${quoteIdent(next)}`);
-          throw error;
-        }
-        await reserved.unsafe(
-          `DROP INDEX IF EXISTS ${quoteIdent(name)}; ALTER INDEX ${quoteIdent(next)} RENAME TO ${quoteIdent(name)}`,
-        );
+        await fn(reserved);
       } finally {
         await reserved.unsafe(`SELECT pg_advisory_unlock(hashtext(current_schema() || $1))`, [key]);
       }

package/service/predefinedAdaptor/sql/SqlDocumentStore.ts

@@ -5,6 +5,7 @@ import { Err } from "akanjs/dictionary";
 import {
   createDocumentId,
   type DatabaseModel,
+  type DocumentIndexDescriptor,
   type DocumentQuery,
   type DocumentSchema,
   type DocumentScopeOptions,
@@ -66,12 +67,17 @@ interface DeclaredIndex {
   next: string;
   metaKey: string;
   hash: string;
-  fields: Record<string, unknown>;
-  /** A key ordered neither 1 nor -1, as MongoDB's `"text"`: no SQL index here stands for it. */
-  unbuilt: boolean;
+  /** Every descriptor that declares this very index, so a copy an earlier release built under any of them serves it. */
+  hashes: Set<string>;
   create: (name: string, concurrently: boolean) => string;
 }
 
+interface StaleIndex {
+  name: string;
+  metaKey: string;
+  exists: boolean;
+}
+
 type StoredRow = Omit<SqliteDocumentRow, "id">;
 
 const freshDefault = (value: unknown) => (Array.isArray(value) ? [...(value as unknown[])] : value);
@@ -115,8 +121,8 @@ export class SqlDocumentStore {
 
   async #ensure() {
     this.assertValidRefName(this.table);
-    const declared = await this.#declaredIndexes();
-    const indexes = declared.filter((index) => !index.unbuilt);
+    const indexes = await this.#declaredIndexes();
+    for (const index of this.schema.indexes) if (!SqlDocumentStore.#builds(index)) this.#warnUnbuilt(index);
     const createSchema = async () => {
       const db = this.owner.getConnection();
       const existed = !!this.owner.buildIndexConcurrently && !!(await this.owner.hasTable?.(this.table));
@@ -135,9 +141,10 @@ export class SqlDocumentStore {
         `table:${this.table}`,
         await descriptorHash({ table: this.table, columns: ["id", "createdAt", "updatedAt", "removedAt", "_doc"] }),
       );
-      for (const index of declared) if (index.unbuilt) await this.#skipUnbuiltIndex(index, indexes);
+      const { adopted, stale } = await this.#reconcileIndexes(indexes);
       const concurrent: (DeclaredIndex & { replace: boolean })[] = [];
       for (const index of indexes) {
+        if (adopted.has(index.name)) continue;
         const stored = await this.owner.getMeta(index.metaKey);
         const replace = !!stored && stored !== index.hash;
         if (replace)
@@ -156,51 +163,141 @@ export class SqlDocumentStore {
         else await db.execute(index.create(index.name, false));
         await this.owner.setMeta(index.metaKey, index.hash);
       }
-      return concurrent;
+      const drops: StaleIndex[] = [];
+      for (const index of stale) {
+        if (!index.exists) await this.owner.deleteMeta(index.metaKey);
+        else if (this.owner.dropIndexConcurrently) drops.push(index);
+        else await this.#dropStaleIndex(index);
+      }
+      return { concurrent, drops };
     };
-    const concurrent = this.owner.lockSchema ? await this.owner.lockSchema(createSchema) : await createSchema();
+    const { concurrent, drops } = this.owner.lockSchema
+      ? await this.owner.lockSchema(createSchema)
+      : await createSchema();
     for (const { name, next, create, replace, metaKey, hash } of concurrent) {
       await this.owner.buildIndexConcurrently?.({ name, next, create: (target) => create(target, true), replace });
       await this.owner.setMeta(metaKey, hash);
     }
+    for (const index of drops) await this.#dropStaleIndex(index);
     await this.owner.getSearchIndex()?.ensureRef(this.constant, this.database);
   }
 
+  static #builds(index: DocumentIndexDescriptor) {
+    return Object.values(index.fields).every((order) => order === 1 || order === -1);
+  }
+
   async #declaredIndexes(): Promise<DeclaredIndex[]> {
-    return await Promise.all(
-      this.schema.indexes.map(async (index, idx) => {
-        const declared = index.name ?? `${this.table}_${Object.keys(index.fields).map(toSafeRefName).join("_")}_${idx}`;
-        this.assertValidRefName(declared);
-        const name = this.dialect.indexName(declared);
-        const unbuilt = Object.values(index.fields).some((order) => order !== 1 && order !== -1);
-        const columns = unbuilt
-          ? []
-          : Object.keys(index.fields).map((path) => ({
-              path,
-              expr: this.compiler.fieldExpr(path),
-              isArray: this.compiler.isArrayPath(path),
-            }));
-        const predicate = unbuilt || !index.where ? undefined : this.#indexPredicate(index.where, name);
+    const candidates = await Promise.all(
+      this.schema.indexes.filter(SqlDocumentStore.#builds).map(async (descriptor) => {
+        const paths = Object.keys(descriptor.fields);
+        const base =
+          descriptor.name ??
+          [this.table, ...paths.map(toSafeRefName), ...(descriptor.unique ? ["unique"] : [])].join("_");
+        const columns = paths.map((path) => ({
+          path,
+          expr: this.compiler.fieldExpr(path),
+          isArray: this.compiler.isArrayPath(path),
+        }));
+        const predicate = descriptor.where ? this.#indexPredicate(descriptor.where, base) : undefined;
+        const create = (target: string, concurrently: boolean) =>
+          this.dialect.createIndex({
+            name: target,
+            table: this.table,
+            unique: !!descriptor.unique,
+            columns,
+            concurrently,
+            where: predicate,
+          });
+        const definition = create("", false);
         return {
-          name,
-          next: this.dialect.indexName(`${declared}_next`),
-          metaKey: `index:${this.table}:${name}`,
+          named: !!descriptor.name,
+          base,
+          definition,
           
-          hash: await descriptorHash(predicate ? { ...index, predicate } : index),
-          fields: index.fields,
-          unbuilt,
-          create: (target: string, concurrently: boolean) =>
-            this.dialect.createIndex({
-              name: target,
-              table: this.table,
-              unique: !!index.unique,
-              columns,
-              concurrently,
-              where: predicate,
-            }),
+          hash: await descriptorHash(predicate ? { ...descriptor, predicate } : descriptor),
+          suffix: (await descriptorHash(definition)).slice(0, 8),
+          create,
         };
       }),
     );
+    const definitionsOf = new Map<string, Set<string>>();
+    for (const { base, definition } of candidates)
+      definitionsOf.set(base, (definitionsOf.get(base) ?? new Set()).add(definition));
+    const namedDefinitions = new Set(candidates.filter(({ named }) => named).map(({ definition }) => definition));
+    const indexes = new Map<string, DeclaredIndex>();
+    for (const { named, base, definition, hash, suffix, create } of candidates) {
+      if (!named && namedDefinitions.has(definition)) continue;
+      
+      const shared = (definitionsOf.get(base)?.size ?? 0) > 1;
+      if (
+        named &&
+        shared &&
+        candidates.some((other) => other.named && other.base === base && other.definition !== definition)
+      )
+        throw new Error(`Two different indexes on ${this.table} are both named ${base}`);
+      const declared = named || !shared ? base : `${base}_${suffix}`;
+      this.assertValidRefName(declared);
+      const name = this.dialect.indexName(declared);
+      const existing = indexes.get(name);
+      if (existing) {
+        existing.hashes.add(hash);
+        continue;
+      }
+      indexes.set(name, {
+        name,
+        next: this.dialect.indexName(`${declared}_next`),
+        metaKey: `index:${this.table}:${name}`,
+        hash,
+        hashes: new Set([hash]),
+        create,
+      });
+    }
+    return [...indexes.values()];
+  }
+
+  async #reconcileIndexes(indexes: DeclaredIndex[]) {
+    const prefix = `index:${this.table}:`;
+    const { sql, params } = this.dialect.indexesOf(this.table);
+    const rows = await this.owner
+      .getConnection()
+      .prepare(sql)
+      .all<{ name: string; valid: unknown }>(...params);
+    const physical = new Map(rows.map(({ name, valid }) => [name, !!valid]));
+    const declared = new Set(indexes.map(({ name }) => name));
+    const recorded = (await this.owner.listMeta(prefix)).map(({ key, value }) => ({
+      name: key.slice(prefix.length),
+      metaKey: key,
+      hash: value,
+    }));
+    const recordedNames = new Set(recorded.map(({ name }) => name));
+    const undeclared = recorded.filter(({ name }) => !declared.has(name)).sort((a, b) => a.name.localeCompare(b.name));
+    
+    const kept = new Set<string>();
+    const adopted = new Set<string>();
+    for (const index of indexes) {
+      if (recordedNames.has(index.name) || physical.has(index.name)) continue;
+      const copy = undeclared.find(({ name, hash }) => !kept.has(name) && index.hashes.has(hash) && physical.get(name));
+      if (!copy) continue;
+      kept.add(copy.name);
+      adopted.add(index.name);
+    }
+    const stale: StaleIndex[] = undeclared
+      .filter(({ name }) => !kept.has(name))
+      .map(({ name, metaKey }) => ({ name, metaKey, exists: physical.has(name) }));
+    return { adopted, stale };
+  }
+
+  async #dropStaleIndex({ name, metaKey }: StaleIndex) {
+    try {
+      if (this.owner.dropIndexConcurrently) await this.owner.dropIndexConcurrently(name);
+      else await this.owner.getConnection().execute(`DROP INDEX IF EXISTS ${quoteIdent(name)}`);
+      await this.owner.deleteMeta(metaKey);
+      SqlDocumentStore.#logger.info(`Dropped index ${name} on ${this.table}, which no declaration builds any more`);
+    } catch (error) {
+      SqlDocumentStore.#logger.warn(
+        `Index ${name} on ${this.table} is no longer declared, and dropping it failed: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
   }
 
   #indexPredicate(where: DocumentQuery, name: string) {
@@ -210,20 +307,13 @@ export class SqlDocumentStore {
     return sql === "1 = 1" ? undefined : inlineParams(sql, params);
   }
 
-  async #skipUnbuiltIndex(index: DeclaredIndex, built: DeclaredIndex[]) {
-    const dropped =
-      (await this.owner.getMeta(index.metaKey)) === index.hash && !built.some(({ name }) => name === index.name);
-    if (dropped) {
-      await this.owner.getConnection().execute(`DROP INDEX IF EXISTS ${quoteIdent(index.name)}`);
-      
-      await this.owner.setMeta(index.metaKey, "");
-    }
+  #warnUnbuilt(index: DocumentIndexDescriptor) {
     const paths = Object.keys(index.fields);
     SqlDocumentStore.#logger.warn(
       `Index ${JSON.stringify(index.fields)} on ${this.table} is not built: only 1 and -1 order a key, and "text" is ` +
         `MongoDB's text index, which as a B-tree would copy each whole value and fail long writes on Postgres. Search ` +
         `${paths.join(", ")} through the full-text role, field(String, { text: "desc" }), or declare ` +
-        `{ ${paths[0]}: 1 } to look it up by equality.${dropped ? ` Dropped ${index.name}, which an earlier boot built from it.` : ""}`,
+        `{ ${paths[0]}: 1 } to look it up by equality.`,
     );
   }
 

package/service/predefinedAdaptor/sql/dialect/postgres.ts

@@ -171,6 +171,13 @@ export class PostgresDialect implements SqlDialect {
     
     return `${create} (${columns.map(({ expr }) => `${expr} NULLS FIRST`).join(", ")})${predicate}`;
   }
+  
+  indexesOf(table: string): SqlFrag {
+    return {
+      sql: `SELECT c.relname AS "name", i.indisvalid AS "valid" FROM pg_index i JOIN pg_class c ON c.oid = i.indexrelid WHERE i.indrelid = to_regclass(?) AND NOT i.indisprimary`,
+      params: [quoteIdent(table)],
+    };
+  }
   applyUpdate(acc: string, op: DocumentUpdateOperator, path: string, value: unknown): SqlFrag {
     const p = this.#path(path);
     

package/service/predefinedAdaptor/sql/dialect/sqlite.ts

@@ -93,6 +93,13 @@ export class SqliteDialect implements SqlDialect {
   createIndex({ name, table, unique, columns, where }: CreateIndexProps) {
     return `CREATE ${unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${quoteIdent(name)} ON ${quoteIdent(table)} (${columns.map(({ expr }) => expr).join(", ")})${where ? ` WHERE ${where}` : ""}`;
   }
+  
+  indexesOf(table: string): SqlFrag {
+    return {
+      sql: `SELECT "name", 1 AS "valid" FROM "sqlite_master" WHERE "type" = 'index' AND "tbl_name" = ? AND "sql" IS NOT NULL`,
+      params: [table],
+    };
+  }
   applyUpdate(acc: string, op: DocumentUpdateOperator, path: string, value: unknown): SqlFrag {
     const p = this.#path(path);
     

package/service/predefinedAdaptor/sql/types.ts

@@ -194,6 +194,8 @@ export interface DocumentDatabaseOwner {
   getSearchIndex(): SearchIndex | null;
   getMeta(key: string): Promise<string | undefined> | string | undefined;
   setMeta(key: string, value: string): Promise<void>;
+  listMeta(prefix: string): Promise<{ key: string; value: string }[]> | { key: string; value: string }[];
+  deleteMeta(key: string): Promise<void>;
   afterCommit(fn: () => PromiseOrObject<void>): Promise<void>;
   transaction?<T>(fn: () => PromiseOrObject<T>): Promise<T>;
   /** Runs `fn` as the only schema change: Postgres races two `CREATE … IF NOT EXISTS` into a duplicate-key error. */
@@ -204,6 +206,8 @@ export interface DocumentDatabaseOwner {
   grantInsight?(table: string): Promise<void>;
   /** Builds an index on a table that already holds rows without blocking its writes; never inside a transaction. */
   buildIndexConcurrently?(build: ConcurrentIndexBuild): Promise<void>;
+  /** Drops an index without blocking its table's reads and writes; never inside a transaction. */
+  dropIndexConcurrently?(name: string): Promise<void>;
 }
 
 export const QUERY_OPERATOR_KEYS = queryOperatorKeys;
@@ -276,6 +280,8 @@ export interface SqlDialect {
   orderTerm(expr: string, direction: 1 | -1): string;
   indexName(name: string): string;
   createIndex(props: CreateIndexProps): string;
+  /** Rows `{ name, valid }`, one per index on `table` besides its primary key. */
+  indexesOf(table: string): SqlFrag;
   applyUpdate(acc: string, op: DocumentUpdateOperator, path: string, value: unknown): SqlFrag;
   /** The stored document with these top-level fields replaced (value as JSON text) and these removed. */
   mergeDocument(set: [field: string, json: string][], removed: string[]): SqlFrag;

package/types/service/predefinedAdaptor/database.adaptor.d.ts

@@ -40,6 +40,11 @@ export declare class SqliteDatabase extends SqliteDatabase_base implements Datab
     getStore(constant: ConstantModel, database: DatabaseModel, schema: SchemaOf): SqlDocumentStore;
     getMeta(key: string): string | undefined;
     setMeta(key: string, value: string): Promise<void>;
+    listMeta(prefix: string): {
+        key: string;
+        value: string;
+    }[];
+    deleteMeta(key: string): Promise<void>;
     transaction<T>(fn: () => PromiseOrObject<T>): Promise<T>;
     afterCommit(fn: () => PromiseOrObject<void>): Promise<void>;
     checkpoint(mode?: "PASSIVE" | "FULL" | "RESTART" | "TRUNCATE"): void;
@@ -71,10 +76,16 @@ export declare class PostgresDatabase extends PostgresDatabase_base implements D
     getStore(constant: ConstantModel, database: DatabaseModel, schema: SchemaOf): SqlDocumentStore;
     getMeta(key: string): Promise<string | undefined>;
     setMeta(key: string, value: string): Promise<void>;
+    listMeta(prefix: string): Promise<{
+        key: string;
+        value: string;
+    }[]>;
+    deleteMeta(key: string): Promise<void>;
     transaction<T>(fn: () => PromiseOrObject<T>): Promise<T>;
     afterCommit(fn: () => PromiseOrObject<void>): Promise<void>;
     lockSchema<T>(fn: () => Promise<T>): Promise<T>;
     hasTable(table: string): Promise<boolean>;
     hasValidIndex(name: string): Promise<boolean>;
     buildIndexConcurrently({ name, next, create, replace }: ConcurrentIndexBuild): Promise<void>;
+    dropIndexConcurrently(name: string): Promise<void>;
 }

package/types/service/predefinedAdaptor/sql/dialect/postgres.d.ts

@@ -30,6 +30,7 @@ export declare class PostgresDialect implements SqlDialect {
     orderTerm(expr: string, direction: 1 | -1): string;
     indexName(name: string): string;
     createIndex({ name, table, unique, columns, concurrently, where }: CreateIndexProps): string;
+    indexesOf(table: string): SqlFrag;
     applyUpdate(acc: string, op: DocumentUpdateOperator, path: string, value: unknown): SqlFrag;
     mergeDocument(set: [field: string, json: string][], removed: string[]): SqlFrag;
     affectedRows(result: unknown): number;

package/types/service/predefinedAdaptor/sql/dialect/sqlite.d.ts

@@ -25,6 +25,7 @@ export declare class SqliteDialect implements SqlDialect {
     orderTerm(expr: string, direction: 1 | -1): string;
     indexName(name: string): string;
     createIndex({ name, table, unique, columns, where }: CreateIndexProps): string;
+    indexesOf(table: string): SqlFrag;
     applyUpdate(acc: string, op: DocumentUpdateOperator, path: string, value: unknown): SqlFrag;
     mergeDocument(set: [field: string, json: string][], removed: string[]): SqlFrag;
     affectedRows(result: unknown): number;

package/types/service/predefinedAdaptor/sql/types.d.ts

@@ -198,6 +198,14 @@ export interface DocumentDatabaseOwner {
     getSearchIndex(): SearchIndex | null;
     getMeta(key: string): Promise<string | undefined> | string | undefined;
     setMeta(key: string, value: string): Promise<void>;
+    listMeta(prefix: string): Promise<{
+        key: string;
+        value: string;
+    }[]> | {
+        key: string;
+        value: string;
+    }[];
+    deleteMeta(key: string): Promise<void>;
     afterCommit(fn: () => PromiseOrObject<void>): Promise<void>;
     transaction?<T>(fn: () => PromiseOrObject<T>): Promise<T>;
     /** Runs `fn` as the only schema change: Postgres races two `CREATE … IF NOT EXISTS` into a duplicate-key error. */
@@ -208,6 +216,8 @@ export interface DocumentDatabaseOwner {
     grantInsight?(table: string): Promise<void>;
     /** Builds an index on a table that already holds rows without blocking its writes; never inside a transaction. */
     buildIndexConcurrently?(build: ConcurrentIndexBuild): Promise<void>;
+    /** Drops an index without blocking its table's reads and writes; never inside a transaction. */
+    dropIndexConcurrently?(name: string): Promise<void>;
 }
 export declare const QUERY_OPERATOR_KEYS: Set<string>;
 export interface SqlFrag {
@@ -271,6 +281,8 @@ export interface SqlDialect {
     orderTerm(expr: string, direction: 1 | -1): string;
     indexName(name: string): string;
     createIndex(props: CreateIndexProps): string;
+    /** Rows `{ name, valid }`, one per index on `table` besides its primary key. */
+    indexesOf(table: string): SqlFrag;
     applyUpdate(acc: string, op: DocumentUpdateOperator, path: string, value: unknown): SqlFrag;
     /** The stored document with these top-level fields replaced (value as JSON text) and these removed. */
     mergeDocument(set: [field: string, json: string][], removed: string[]): SqlFrag;

package/ui/Tab/Provider.tsx

@@ -147,14 +147,12 @@ export interface PanelProps {
 }
 export const Panel = ({ className, menu, children, loading = "eager" }: PanelProps) => {
   const { menu: currentMenu } = useContext(TabContext);
-  const [loaded, setLoaded] = useState(menu === currentMenu);
-
+  const isShown = currentMenu === menu;
+  const [loaded, setLoaded] = useState(isShown);
+  const isMounted = loading === "eager" || isShown || (loading === "lazy" && loaded);
   useEffect(() => {
-    if (loading === "eager") setLoaded(true);
-    else if (loading === "lazy" && !loaded && currentMenu === menu) setLoaded(true);
-    else if (loading === "every") setLoaded(currentMenu === menu);
-  }, [currentMenu]);
+    setLoaded(isMounted);
+  }, [isMounted]);
 
-  if (loading === "eager") return <div className={cn(className, currentMenu !== menu && "hidden")}>{children}</div>;
-  else return loaded ? <div className={cn(className, currentMenu !== menu && "hidden")}>{children}</div> : null;
+  return isMounted ? <div className={cn(className, !isShown && "hidden")}>{children}</div> : null;
 };