@hot-updater/server 1.0.0-rc.16 → 1.0.0-rc.18

package/src/database/sql/sqlAdapter.readBudgets.integration.spec.ts

@@ -40,6 +40,8 @@ const ready = async (connect: () => Promise<unknown>) => {
   }
 };
 
+const MYSQL_URI = "mysql://root:hot_updater@127.0.0.1:53306/hot_updater";
+
 let postgres: pg.Pool;
 let mariadb: mysql.Pool;
 
@@ -50,11 +52,23 @@ beforeAll(async () => {
       "postgres://postgres:hot_updater@127.0.0.1:55432/hot_updater",
     max: 16,
   });
-  mariadb = mysql.createPool({
-    uri: "mysql://root:hot_updater@127.0.0.1:53306/hot_updater",
-    connectionLimit: 16,
-  });
   await ready(() => postgres.query("SELECT 1"));
+  // Each row a plan evaluates costs as much as an index entry it reads, as
+  // PostgreSQL's planner settings make it, so a small table plans like a
+  // production-sized one: an index range rather than a primary-key prefix
+  // filtered down to it. Sessions opened after the flush use the new cost.
+  await ready(async () => {
+    const admin = await mysql.createConnection(MYSQL_URI);
+    try {
+      await admin.query(
+        "UPDATE mysql.server_cost SET cost_value = 1 WHERE cost_name = 'row_evaluate_cost'",
+      );
+      await admin.query("FLUSH OPTIMIZER_COSTS");
+    } finally {
+      await admin.end();
+    }
+  });
+  mariadb = mysql.createPool({ uri: MYSQL_URI, connectionLimit: 16 });
   await ready(() => mariadb.query("SELECT 1"));
 }, 180_000);
 

package/src/database/sql/sqlAdapter.spec.ts

@@ -4,12 +4,13 @@ import { PGlite } from "@electric-sql/pglite";
 import type { PhysicalTable } from "@hot-updater/plugin-core/internal";
 import {
   conformanceCounters,
+  conformanceExpiring,
   conformanceItems,
   setupDatabaseAdapterConformanceSuite,
 } from "@hot-updater/test-utils";
 import { afterAll, describe, expect, it } from "vitest";
 
-import { builtInSchema } from "../../db/builtInDatabase";
+import { coreSchema } from "../../db/coreDatabase";
 import {
   classifySqlError,
   createSqlAdapter,
@@ -18,6 +19,7 @@ import {
   type SqlStatement,
   WRITE_GUARD_TABLE,
 } from "./sqlAdapter";
+import { pruneStatements } from "./sqlSchema";
 import {
   pgliteBatchExecutor,
   pgliteExecutor,
@@ -145,9 +147,9 @@ describe("sql core", () => {
     expect(() => createTableStatements("mysql", [catalogs(false)])).toThrow(
       "catalogs key needs 8192 bytes on MySQL, over its 3072",
     );
-    // every table the façade spans fits
+    // every core table fits; the plugins' tables are checked beside them
     expect(() =>
-      createTableStatements("mysql", builtInSchema.tables),
+      createTableStatements("mysql", coreSchema.tables),
     ).not.toThrow();
   });
 
@@ -236,6 +238,92 @@ describe("sql core", () => {
     ]);
   });
 
+  it("indexes a retention column that no index or key already leads with", () => {
+    const index = (table: PhysicalTable) =>
+      createTableStatements("postgresql", [table]).filter((statement) =>
+        statement.includes("__retention"),
+      );
+    expect(index(conformanceExpiring)).toEqual([
+      'CREATE INDEX IF NOT EXISTS "conformance_expiring__retention" ON "conformance_expiring" ("at", "id")',
+    ]);
+    // An index or a key that starts with the column serves a prune already.
+    const led = (retention: PhysicalTable["retention"]) =>
+      index({ ...conformanceCounters, retention });
+    expect(led({ column: "scope", ms: 1 })).toEqual([]);
+    expect(
+      index({
+        ...conformanceExpiring,
+        indexes: [{ name: "byAt", eq: ["at"], sort: [] }],
+      }),
+    ).toEqual([]);
+    expect(led({ column: "hits", ms: 1 })).toEqual([
+      'CREATE INDEX IF NOT EXISTS "conformance_counters__retention" ON "conformance_counters" ("hits", "scope", "shard")',
+    ]);
+  });
+
+  it("walks expired rows in the order of the index that leads with the retention column", () => {
+    const events: PhysicalTable = {
+      ...conformanceExpiring,
+      columns: [
+        ...conformanceExpiring.columns,
+        { name: "received", type: "integer", nullable: false },
+      ],
+      indexes: [{ name: "byAt", eq: ["at"], sort: ["received"] }],
+    };
+    const [postgres] = pruneStatements("postgresql", events, "", 10).map(
+      (render) => render(() => "$1"),
+    );
+    expect(postgres).toBe(
+      'DELETE FROM "conformance_expiring" WHERE "conformance_expiring"."at" <= $1 AND ("conformance_expiring"."at", "conformance_expiring"."received", "conformance_expiring"."id") <= (SELECT b."at", b."received", b."id" FROM (SELECT i."at", i."received", i."id" FROM "conformance_expiring" i WHERE i."at" <= $1 ORDER BY i."at" ASC, i."received" ASC, i."id" ASC LIMIT 10) b ORDER BY b."at" DESC, b."received" DESC, b."id" DESC LIMIT 1)',
+    );
+    const [entries, rows] = pruneStatements(
+      "mysql",
+      conformanceExpiring,
+      "",
+      10,
+    ).map((render) => render(() => "?"));
+    expect(entries).toBe(
+      "DELETE e FROM `conformance_expiring__byTag` e JOIN (SELECT i.`at`, i.`id` FROM `conformance_expiring` i WHERE i.`at` <= ? ORDER BY i.`at` ASC, i.`id` ASC LIMIT 10) d ON e.`id` = d.`id`",
+    );
+    expect(rows).toBe(
+      "DELETE FROM `conformance_expiring` WHERE `at` <= ? ORDER BY `at`, `id` LIMIT 10",
+    );
+  });
+
+  it.each(["PGlite", "SQLite"] as const)(
+    "prunes expired rows with their index table entries on %s",
+    async (engine) => {
+      const sqlite = engine === "SQLite" ? new DatabaseSync(":memory:") : null;
+      tests += 1;
+      const executor = sqlite ? sqliteExecutor(sqlite) : pgliteExecutor(pglite);
+      const prefix = sqlite ? "" : `t${tests}_`;
+      const adapter = createSqlAdapter({ executor, tablePrefix: prefix });
+      await adapter.migrations!.apply([conformanceExpiring]);
+      await adapter.write(
+        [5, 10, 20, null].map((at, position) => ({
+          type: "insert",
+          table: conformanceExpiring,
+          row: { id: `r${position}`, grp: "g", at, tags: ["a", "b"], _v: 0 },
+        })),
+      );
+      const count = async (name: string) =>
+        Number(
+          (
+            await executor.execute({
+              sql: `SELECT COUNT(*) AS n FROM "${prefix}${name}"`,
+              params: [],
+            })
+          ).rows[0]!.n,
+        );
+
+      expect(await adapter.prune!(conformanceExpiring, 10, 500)).toBe(2);
+      expect(await count("conformance_expiring")).toBe(2);
+      // Each row had two tag entries; the pruned rows' went with them.
+      expect(await count("conformance_expiring__byTag")).toBe(4);
+      sqlite?.close();
+    },
+  );
+
   it("classifies constraint and transient driver errors", () => {
     const withCode = (fields: Record<string, unknown>) =>
       Object.assign(new Error("driver"), fields);

package/src/database/sql/sqlAdapter.ts

@@ -20,6 +20,7 @@ import {
 import {
   createTableStatements,
   isMultiIndex,
+  pruneStatements,
   quoteSql,
   type SqlDialect,
 } from "./sqlSchema";
@@ -515,6 +516,25 @@ export const createSqlAdapter = ({
       }
     },
 
+    async prune(table, before, limit) {
+      const statements = pruneStatements(
+        dialect,
+        table,
+        tablePrefix,
+        limit,
+      ).map((render) => sql((bind) => render(() => bind(before))));
+      const results = executor.batch
+        ? await executor.batch(statements)
+        : await executor.transaction(async (connection) => {
+            const done: SqlResult[] = [];
+            for (const statement of statements) {
+              done.push(await connection.execute(statement));
+            }
+            return done;
+          });
+      return results.at(-1)?.changes ?? 0;
+    },
+
     migrations: {
       async apply(tables) {
         // A batching executor's writes also need the write guard table.

package/src/database/sql/sqlSchema.ts

@@ -155,6 +155,16 @@ export const sqlTableShapes = (
         },
       ];
     });
+    // A prune walks expired rows in an index's order, so one leads with the column.
+    const retention = table.retention && retentionOrder(table);
+    if (retention && !retention.indexed) {
+      indexes.push({
+        kind: "index",
+        name: shortSqlName(`${name}__retention`),
+        unique: false,
+        columns: retention.columns,
+      });
+    }
     return {
       name,
       columns: table.columns.map((column) => ({
@@ -203,3 +213,74 @@ export const createTableStatements = (
   };
   return sqlTableShapes(dialect, tables, tablePrefix).flatMap(render);
 };
+
+/**
+ * The order a prune walks a table's expired rows in, which ends with the
+ * key so it is total: the columns of the first index that leads with the
+ * retention column, or the key when it does, or else the column and the
+ * key, which then need an index of their own (`indexed` false).
+ */
+export const retentionOrder = (table: PhysicalTable) => {
+  const { column } = table.retention!;
+  for (const index of table.indexes) {
+    const columns = [...index.eq, ...indexOrderColumns(table, index)];
+    if (!index.unique && !isMultiIndex(table, index) && columns[0] === column) {
+      return { columns, indexed: true };
+    }
+  }
+  if (table.key[0] === column) return { columns: table.key, indexed: true };
+  const key = table.key.filter((field) => field !== column);
+  return { columns: [column, ...key], indexed: false };
+};
+
+/**
+ * The statements that delete up to `limit` expired rows of a table with
+ * retention, oldest first in {@link retentionOrder}: its multi-valued index
+ * entries, then the rows, which a concurrent write that moved the retention
+ * column past `before` keeps. `before` renders the bound each time it
+ * appears. MySQL deletes with ORDER BY and LIMIT. Elsewhere the cutoff is
+ * the last of the `limit` oldest expired rows in that order, a row value
+ * the index ranges over, and the shapes pass Supabase's apply RPC: no IN, no
+ * AS, aliases `i` and `b`.
+ */
+export const pruneStatements = (
+  dialect: SqlDialect,
+  table: PhysicalTable,
+  tablePrefix: string,
+  limit: number,
+): ((before: () => string) => string)[] => {
+  const quote = (name: string) => quoteSql(dialect, name);
+  const name = quote(`${tablePrefix}${table.name}`);
+  const at = quote(table.retention!.column);
+  const order = retentionOrder(table).columns.map(quote);
+  const list = (alias: string, direction = "") =>
+    order.map((column) => `${alias}.${column}${direction}`).join(", ");
+  const oldest = (before: () => string) =>
+    `SELECT ${list("i")} FROM ${name} i WHERE i.${at} <= ${before()} ORDER BY ${list("i", " ASC")} LIMIT ${limit}`;
+  const doomed = (alias: string, before: () => string) =>
+    `${alias}.${at} <= ${before()} AND (${list(alias)}) <= (SELECT ${list("b")} FROM (${oldest(before)}) b ORDER BY ${list("b", " DESC")} LIMIT 1)`;
+  const entries = table.indexes
+    .filter((index) => isMultiIndex(table, index))
+    .map((index) => quote(`${tablePrefix}${table.name}__${index.name}`));
+  const keyOf = (left: string, right: string) =>
+    table.key
+      .map((column) => `${left}.${quote(column)} = ${right}.${quote(column)}`)
+      .join(" AND ");
+  if (dialect === "mysql") {
+    return [
+      ...entries.map(
+        (index) => (before: () => string) =>
+          `DELETE e FROM ${index} e JOIN (${oldest(before)}) d ON ${keyOf("e", "d")}`,
+      ),
+      (before) =>
+        `DELETE FROM ${name} WHERE ${at} <= ${before()} ORDER BY ${order.join(", ")} LIMIT ${limit}`,
+    ];
+  }
+  return [
+    ...entries.map(
+      (index) => (before: () => string) =>
+        `DELETE FROM ${index} WHERE EXISTS (SELECT * FROM ${name} b WHERE ${keyOf("b", index)} AND ${doomed("b", before)})`,
+    ),
+    (before) => `DELETE FROM ${name} WHERE ${doomed(name, before)}`,
+  ];
+};

package/src/databaseTestSuite.spec.ts

@@ -7,6 +7,7 @@ import {
 import { createDatabasePluginApis } from "./assembly/databasePlugins";
 import { createHotUpdater } from "./index";
 import { createInsightsModel, insights } from "./plugins/insights";
+import { insightsTestSuite } from "./plugins/insights/testing";
 
 let adapter = createMemoryAdapter();
 
@@ -32,8 +33,12 @@ setupDatabaseTestSuite({
         clientAccess: "public",
       }).handlers,
     ),
-  createInsightsModel: (database) =>
-    createInsightsModel(
-      createDatabasePluginApis(database, [insights()]).insights,
-    ),
+  plugins: [
+    insightsTestSuite({
+      createModel: (database) =>
+        createInsightsModel(
+          createDatabasePluginApis(database, [insights()]).insights,
+        ),
+    }),
+  ],
 });

package/src/db/coreDatabase.ts

@@ -0,0 +1,153 @@
+import type { AggregateBatching } from "@hot-updater/plugin-core";
+import type { DatabaseAdapter } from "@hot-updater/plugin-core/internal";
+
+import { coreModule, HOT_UPDATER_SCHEMA_VERSION } from "../core/schema";
+import type { ModelShape } from "../database/definitions";
+import {
+  ENGINE_SCHEMA_KEY,
+  ENGINE_SCHEMA_VERSION,
+  isMissingSchemaError,
+  readSettings,
+  withSchemaFence,
+  type SchemaSettings,
+} from "../database/fence";
+import { resolveSchema } from "../database/resolveSchema";
+import { createEngineMigrator } from "./engineMigrator";
+import { migrateSchema } from "./schemaSettings";
+import type { ToolingDatabase, ToolingTarget } from "./types";
+
+/** Core's tables: the tables every provider's tooling creates. */
+export const coreSchema = resolveSchema([coreModule]);
+
+/** The settings rows a provider's database is fenced by. */
+export const coreSettings: SchemaSettings = {
+  [ENGINE_SCHEMA_KEY]: ENGINE_SCHEMA_VERSION,
+  "schema.core": HOT_UPDATER_SCHEMA_VERSION,
+};
+
+/** What `hot-updater db` creates for a server without plugins. */
+export const coreTarget: ToolingTarget = {
+  schema: coreSchema,
+  settings: coreSettings,
+};
+
+/** A plugin as the tooling reads it: its id, its tables, and their version. */
+export interface PluginTables {
+  readonly id: string;
+  readonly schemaVersion: string;
+  readonly schema: Readonly<Record<string, ModelShape>>;
+  /** `false` keeps the declared table names instead of prefixing them with the id. */
+  readonly namespace?: false;
+}
+
+/** Each plugin's `schema.<id>` settings row. */
+export const pluginSettings = (
+  plugins: readonly PluginTables[],
+): SchemaSettings =>
+  Object.fromEntries(
+    plugins.map(({ id, schemaVersion }) => [`schema.${id}`, schemaVersion]),
+  );
+
+/** A plugin's schema as the engine resolves it: prefixed by its id unless it keeps its names. */
+export const pluginModule = <TSchema>({
+  id,
+  schema,
+  namespace,
+}: {
+  readonly id: string;
+  readonly schema: TSchema;
+  readonly namespace?: false;
+}) => ({
+  id,
+  schema,
+  ...(namespace === false ? {} : { namespace: id }),
+});
+
+/**
+ * What `hot-updater db` creates for a server's plugins: core's tables, then
+ * each plugin's tables with its `schema.<id>` settings row.
+ */
+export const toolingTargetOf = (
+  plugins: readonly PluginTables[],
+): ToolingTarget =>
+  plugins.length === 0
+    ? coreTarget
+    : {
+        schema: resolveSchema([coreModule, ...plugins.map(pluginModule)]),
+        settings: { ...coreSettings, ...pluginSettings(plugins) },
+      };
+
+/**
+ * Creates core's tables and those of `plugins`, then writes their settings
+ * rows: what a provider's setup runs for the plugins its server runs.
+ */
+export const migrateCoreSchema = (
+  adapter: DatabaseAdapter,
+  name: string,
+  plugins: readonly PluginTables[] = [],
+) => {
+  const { schema, settings } = toolingTargetOf(plugins);
+  return migrateSchema(adapter, name, schema.tables, settings);
+};
+
+export interface EngineDatabaseOptions {
+  readonly name: string;
+  readonly adapter: DatabaseAdapter;
+  /**
+   * Purges a CDN's copies of the cacheable client routes. Core calls it after
+   * a committed write that changes what those routes answer, since only core
+   * knows which of its tables they read.
+   */
+  readonly onCachedRoutesChange?: () => Promise<void>;
+  /**
+   * Batches aggregates declared `batched`, for stores that bill each write;
+   * `false` or absent commits them with each transaction.
+   */
+  readonly aggregateBatching?: AggregateBatching | false;
+}
+
+/**
+ * A provider's database on the storage engine: its adapter behind the schema
+ * fence, which checks core's settings rows before the first read or write
+ * and names `hot-updater db migrate` when they are missing or stale. When the
+ * adapter creates its own tables, `hot-updater db migrate` creates core's
+ * tables and the server's plugin tables, then writes their settings rows.
+ */
+export const createEngineDatabase = ({
+  name,
+  adapter,
+  onCachedRoutesChange,
+  aggregateBatching,
+}: EngineDatabaseOptions): ToolingDatabase => {
+  const fenced = withSchemaFence(adapter, name, coreSettings);
+  const createMigrator = ({ schema, settings } = coreTarget) =>
+    createEngineMigrator({
+      adapterName: name,
+      adapter,
+      schema,
+      settings,
+      readSettings: async () => {
+        const rows = await readSettings(adapter, Object.keys(settings)).catch(
+          (error: unknown) => {
+            if (isMissingSchemaError(error)) return [];
+            throw error;
+          },
+        );
+        return new Map(
+          rows.flatMap((row) =>
+            row === null ? [] : [[String(row.key), row.value]],
+          ),
+        );
+      },
+    });
+  return {
+    name,
+    adapter: fenced,
+    ...(onCachedRoutesChange === undefined ? {} : { onCachedRoutesChange }),
+    ...(aggregateBatching ? { aggregateBatching } : {}),
+    ...(adapter.dispose === undefined
+      ? {}
+      : { dispose: () => adapter.dispose!() }),
+    ...(adapter.migrations === undefined ? {} : { createMigrator }),
+  };
+};

package/src/db/engineSql.spec.ts

@@ -15,15 +15,16 @@ import {
   pgliteExecutor,
   sqliteExecutor,
 } from "../database/sql/sqlTestExecutors";
-import {
-  builtInSchema,
-  builtInSettings,
-  createEngineDatabase,
-} from "./builtInDatabase";
+import { apiKeys } from "../plugins/api-keys";
+import { insights } from "../plugins/insights";
+import { createEngineDatabase, toolingTargetOf } from "./coreDatabase";
 import { generateEngineSql } from "./engineSql";
 
+/** Core's tables and the Insights and API keys plugins'. */
+const target = toolingTargetOf([insights(), apiKeys()]);
+
 const sql = (dialect: "postgresql" | "mysql" | "sqlite") =>
-  generateEngineSql(dialect, builtInSchema, builtInSettings);
+  generateEngineSql(dialect, target.schema, target.settings);
 
 describe("the shared SQL schema", () => {
   it("defaults engine columns, has no foreign keys, and writes the settings last", () => {
@@ -53,7 +54,7 @@ describe("the shared SQL schema", () => {
   });
 
   it("describes each table as its DDL creates it, for ORM schema generators", () => {
-    const tables = builtInSchema.tables;
+    const tables = target.schema.tables;
     const names = (shapes: readonly SqlTableShape[]): string[] =>
       shapes.flatMap((shape) => [
         shape.name,

package/src/db/index.ts

@@ -2,6 +2,7 @@ import {
   getHotUpdaterCoreMetadata,
   type RuntimeHotUpdaterAPI,
 } from "../createHotUpdaterCore";
+import type { AnyHotUpdaterPlugin } from "../plugins/definePlugin";
 import { type Migrator, type SchemaGenerator } from "./types";
 
 export { createDatabaseCoreApi, type CoreApi } from "../core/api";
@@ -11,8 +12,19 @@ export {
   type MeasuredDatabase,
   type MeasuredDatabaseOptions,
 } from "../assembly/databasePlugins";
+export {
+  clientAuthOf,
+  clientPluginsOf,
+  generateClientCredential,
+  pluginCommandsOf,
+  provisionClientCredential,
+  type ClientAuthSpec,
+  type ClientCredentialSpec,
+  type ClientPluginSpec,
+  type PluginCommandEntry,
+  type ProvisionedClientCredential,
+} from "../assembly/pluginCli";
 export { targetBaseCandidateKey } from "../core/baseCandidates";
-export * from "./createBundleDiff";
 export {
   generateEngineSql,
   settingsStatements,
@@ -44,11 +56,16 @@ const getDBMetadata = (hotUpdater: HotUpdaterDBTarget) => {
   return metadata;
 };
 
+/** A server's plugins as configured, whose commands the CLI adds. */
+export const serverPluginsOf = (
+  hotUpdater: HotUpdaterDBTarget,
+): readonly AnyHotUpdaterPlugin[] => getDBMetadata(hotUpdater).plugins;
+
 /** Whether `hot-updater db generate` writes schema files for a server's database. */
 export const generatesSchema = (hotUpdater: HotUpdaterDBTarget): boolean =>
   getDBMetadata(hotUpdater).database.generateSchema !== undefined;
 
-/** The migrator for a server's database: its built-in tables and its plugins' tables. */
+/** The migrator for a server's database: core's tables and its plugins' tables. */
 export function createMigrator(hotUpdater: HotUpdaterDBTarget): Migrator {
   const { database, target } = getDBMetadata(hotUpdater);
   if (database.createMigrator === undefined) {

package/src/db/pluginTables.spec.ts

@@ -10,13 +10,18 @@ import { prismaAdapter } from "../adapters/prisma";
 import { createHotUpdater } from "../createHotUpdaterCore";
 import { HotUpdaterSchemaMigrationRequiredError } from "../database/fence";
 import { defineTable } from "../database/schema";
-import { definePlugin } from "../plugins/definePlugin";
+import { createTableStatements } from "../database/sql/sqlAdapter";
+import { apiKeys } from "../plugins/api-keys";
+import {
+  type AnyHotUpdaterPlugin,
+  definePlugin,
+} from "../plugins/definePlugin";
 import { insights } from "../plugins/insights";
 import {
-  builtInTarget,
+  coreTarget,
   createEngineDatabase,
   toolingTargetOf,
-} from "./builtInDatabase";
+} from "./coreDatabase";
 import { createMigrator, generateSchema } from "./index";
 
 const notes = definePlugin({
@@ -56,21 +61,33 @@ const migrate = async (hotUpdater: { readonly adapterName: string }) => {
 const memoryDatabase = () =>
   createEngineDatabase({ name: "memory", adapter: createMemoryAdapter() });
 
-describe("third-party plugin tables in db tooling", () => {
-  it("adds each third-party plugin's namespaced tables and settings row to the built-in ones", () => {
-    expect(toolingTargetOf([insights()])).toBe(builtInTarget);
+describe("plugin tables in db tooling", () => {
+  it("adds each plugin's tables and settings row to core's, prefixed by its id unless it keeps its names", () => {
+    expect(toolingTargetOf([])).toBe(coreTarget);
     const target = toolingTargetOf([insights(), notes]);
-    expect(target.schema.tables.map(({ name }) => name)).toEqual([
-      ...builtInTarget.schema.tables.map(({ name }) => name),
-      "notes_notes",
-    ]);
+    const names = target.schema.tables.map(({ name }) => name);
+    expect(names.slice(0, coreTarget.schema.tables.length)).toEqual(
+      coreTarget.schema.tables.map(({ name }) => name),
+    );
+    expect(names).toContain("bundle_events");
+    expect(names.at(-1)).toBe("notes_notes");
     expect(target.settings).toEqual({
-      ...builtInTarget.settings,
+      ...coreTarget.settings,
+      "schema.insights": insights().schemaVersion,
       "schema.notes": "2",
     });
   });
 
-  it("migrates an engine database's built-in and plugin tables with its adapter", async () => {
+  it("fits Hot Updater's own plugins' tables within MySQL's key limit", () => {
+    expect(() =>
+      createTableStatements(
+        "mysql",
+        toolingTargetOf([insights(), apiKeys()]).schema.tables,
+      ),
+    ).not.toThrow();
+  });
+
+  it("migrates an engine database's core and plugin tables with its adapter", async () => {
     const hotUpdater = createHotUpdater({
       database: memoryDatabase(),
       plugins: [notes],
@@ -180,7 +197,7 @@ describe("third-party plugin tables in db tooling", () => {
     ).toContain("model notes_notes {");
   });
 
-  it("rejects a third-party plugin that takes a built-in plugin's id or table", () => {
+  it("checks a plugin's id and tables against core and the other plugins the server runs", () => {
     const named = definePlugin({
       id: "insights",
       schemaVersion: "1",
@@ -197,22 +214,35 @@ describe("third-party plugin tables in db tooling", () => {
       },
       init: () => ({ api: {} }),
     });
-
-    expect(() =>
-      createHotUpdater({
-        database: memoryDatabase(),
-        plugins: [named],
-        clientAccess: "public",
-      }),
-    ).toThrow(`Plugin "insights" uses a built-in plugin's id.`);
-    expect(() =>
+    const unprefixed = definePlugin({
+      id: "shadowCore",
+      namespace: false,
+      schemaVersion: "1",
+      schema: {
+        channels: defineTable({ id: { type: "string" } }, { key: ["id"] }),
+      },
+      init: () => ({ api: {} }),
+    });
+    const start = (plugins: readonly AnyHotUpdaterPlugin[]) => () =>
       createHotUpdater({
         database: memoryDatabase(),
-        plugins: [tabled],
-        clientAccess: "public",
-      }),
-    ).toThrow(
-      'api.keys: table "api_keys" is also declared by apiKeys.api_keys',
+        plugins,
+        ...(plugins.some(({ provides }) => provides?.clientAuth)
+          ? {}
+          : { clientAccess: "public" }),
+      } as Parameters<typeof createHotUpdater>[0]);
+
+    // Only the plugins a server runs get tables, so these fit on their own.
+    expect(start([named])).not.toThrow();
+    expect(start([tabled])).not.toThrow();
+    expect(start([named, insights()])).toThrow(
+      'Plugin "insights" is registered twice.',
+    );
+    expect(start([tabled, apiKeys()])).toThrow(
+      'apiKeys.api_keys: table "api_keys" is also declared by api.keys',
+    );
+    expect(start([unprefixed])).toThrow(
+      'shadowCore.channels: table "channels" is also declared by core.channels',
     );
   });
 });