@hot-updater/server 0.36.7 → 1.0.0-rc.1

package/src/db/index.spec.ts

@@ -1,18 +1,11 @@
 import { PGlite } from "@electric-sql/pglite";
-import type { Bundle, GetBundlesArgs, UpdateInfo } from "@hot-updater/core";
+import type { Bundle } from "@hot-updater/core";
 import { NIL_UUID } from "@hot-updater/core";
-import type {
-  RuntimeStoragePlugin,
-  StorageResolveContext,
-} from "@hot-updater/plugin-core";
-import { createDatabasePlugin } from "@hot-updater/plugin-core";
-import {
-  setupBundleMethodsTestSuite,
-  setupGetUpdateInfoTestSuite,
-} from "@hot-updater/test-utils";
+import { createStoragePlugin } from "@hot-updater/plugin-core";
+import { sql } from "drizzle-orm";
 import { Kysely } from "kysely";
 import { PGliteDialect } from "kysely-pglite-dialect";
-import type { MongoClient } from "mongodb";
+import { type ClientSession, MongoClient } from "mongodb";
 import {
   afterAll,
   afterEach,
@@ -24,20 +17,28 @@ import {
   vi,
 } from "vitest";
 
+import { createInMemoryDatabasePlugin } from "../../../test-utils/test/inMemoryDatabasePlugin";
 import { drizzleAdapter } from "../adapters/drizzle";
 import { kyselyAdapter } from "../adapters/kysely";
 import { mongoAdapter } from "../adapters/mongodb";
 import { prismaAdapter } from "../adapters/prisma";
-import { createHotUpdater } from "../index";
-import { bundleToRow } from "./bundleRows";
 import {
-  createSchemaMigrationSql,
-  createTableSql,
-  hotUpdaterSchemaVersions,
-} from "./hotUpdaterSchema";
+  createHotUpdater as createRuntimeHotUpdater,
+  type CreateHotUpdaterOptions,
+} from "../index";
+import { bundleToRow } from "./bundleRows";
+import { createTableSql, hotUpdaterSchemaVersions } from "./hotUpdaterSchema";
 import { createMigrator, generateSchema } from "./index";
 import { generateDrizzleSchema } from "./schemaGenerators";
-import type { DatabasePluginFactory, ORMProvider } from "./types";
+import type { DatabasePlugin, ORMProvider } from "./types";
+
+const createHotUpdater = (
+  options: Omit<CreateHotUpdaterOptions, "clientAccess">,
+) =>
+  createRuntimeHotUpdater({
+    ...options,
+    clientAccess: { type: "public" },
+  });
 
 const RAW_PRISMA_SCHEMA = `model bundles {
   id String @id
@@ -71,7 +72,7 @@ model bundle_patches {
 }
 model private_hot_updater_settings {
   key String @id
-  value String @default("0.31.0")
+  value String @default("0.36.0")
 }`;
 
 const RAW_DRIZZLE_SCHEMA = `import { relations } from "drizzle-orm";
@@ -135,6 +136,11 @@ export const bundle_patches = pgTable(
       .onDelete("cascade"),
 ])
 
+export const private_hot_updater_settings = pgTable("private_hot_updater_settings", {
+  key: varchar("key", { length: 255 }).primaryKey().notNull(),
+  version: varchar("version", { length: 255 }).notNull().default("0.36.0"),
+})
+
 export const bundle_patchesRelations = relations(bundle_patches, ({ one, many }) => ({
   bundle: one(bundles, {
     relationName: "bundle_patches_bundles_patches",
@@ -150,24 +156,30 @@ export const bundle_patchesRelations = relations(bundle_patches, ({ one, many })
 
 function createTestStoragePlugin(
   protocol: string,
-  resolveFileUrl: (
-    storageUri: string,
-    context?: StorageResolveContext,
-  ) => string,
   readText: (storageUri: string) => Promise<string | null> = async () => null,
-): RuntimeStoragePlugin {
-  return {
+) {
+  return createStoragePlugin({
     name: `${protocol}TestStorage`,
-    supportedProtocol: protocol,
-    profiles: {
-      runtime: {
-        readText,
-        async getDownloadUrl(storageUri, context) {
-          return { fileUrl: resolveFileUrl(storageUri, context) };
-        },
-      },
+    protocol,
+    async get({ storageUri }) {
+      const text = await readText(storageUri);
+      return { response: text === null ? null : new Response(text) };
     },
-  };
+    async getDownloadUrl({ storageUri }) {
+      const prefixes: Record<string, string> = {
+        gs: "https://firebase.example.com/",
+        r2: "https://r2.example.com/",
+        s3: "https://s3.example.com/",
+        "supabase-storage":
+          "https://supabase.example.com/storage/v1/object/sign/",
+      };
+      return {
+        url: storageUri
+          .replace(`${protocol}://`, prefixes[protocol] ?? "")
+          .replace(/([^:]\/)\/+/g, "$1"),
+      };
+    },
+  });
 }
 
 function createSchemaOnlyAdapter({
@@ -180,75 +192,29 @@ function createSchemaOnlyAdapter({
   name: string;
   provider: ORMProvider;
   path: string;
-}): DatabasePluginFactory {
-  const factory: DatabasePluginFactory = () => ({
-    name,
-    async getBundleById() {
-      return null;
-    },
-    async getBundles() {
-      return {
-        data: [],
-        pagination: {
-          currentPage: 1,
-          hasNextPage: false,
-          hasPreviousPage: false,
-          total: 0,
-          totalPages: 0,
-        },
-      };
-    },
-    async getChannels() {
-      return [];
-    },
-    async appendBundle() {},
-    async updateBundle() {},
-    async deleteBundle() {},
-    async commitBundle() {},
-  });
-  factory.adapterName = name;
-  factory.provider = provider;
-  factory.generateSchema = (_version, schemaName = name) => {
-    return {
+}): DatabasePlugin {
+  return {
+    ...createInMemoryDatabasePlugin(),
+    adapterName: name,
+    provider,
+    generateSchema: (_version, schemaName = name) => ({
       code,
       path: path || schemaName,
-    };
+    }),
   };
-  return factory;
 }
 
 const transactionBundle: Bundle = {
+  archiveByteSize: 1_024,
   id: "00000000-0000-0000-0000-000000000777",
   platform: "ios",
-  shouldForceUpdate: false,
-  enabled: true,
   fileHash: "transaction-hash",
   gitCommitHash: null,
-  message: "transaction bundle",
-  channel: "production",
   storageUri: "s3://test-bucket/transaction.zip",
-  targetAppVersion: "1.0.0",
-  fingerprintHash: null,
-};
-
-const appVersionFastPathBundle: Bundle = {
-  ...transactionBundle,
-  id: "00000000-0000-0000-0000-000000000778",
-  fileHash: "app-version-fast-path-hash",
-  message: "app version fast path bundle",
-  targetAppVersion: "1.0.0",
-};
-
-const fingerprintFastPathBundle: Bundle = {
-  ...transactionBundle,
-  id: "00000000-0000-0000-0000-000000000779",
-  fileHash: "fingerprint-fast-path-hash",
-  fingerprintHash: "fingerprint-fast-path",
-  message: "fingerprint fast path bundle",
-  targetAppVersion: null,
 };
+const transactionChannelId = "00000000-0000-0000-0000-000000000700";
 
-describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
+describe("server/db hotUpdater (PGlite + Kysely)", async () => {
   const db = new PGlite();
 
   const kysely = new Kysely<object>({ dialect: new PGliteDialect(db) });
@@ -266,42 +232,11 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
       db: kysely,
       provider: "postgresql",
     }),
-    storages: [
-      createTestStoragePlugin(
-        "s3",
-        (storageUri) =>
-          storageUri
-            .replace("s3://", "https://s3.example.com/")
-            .replace(/([^:]\/)\/+/g, "$1"),
-        readStoredText,
-      ),
-      createTestStoragePlugin(
-        "r2",
-        (storageUri) =>
-          storageUri
-            .replace("r2://", "https://r2.example.com/")
-            .replace(/([^:]\/)\/+/g, "$1"),
-        readStoredText,
-      ),
-      createTestStoragePlugin(
-        "supabase-storage",
-        (storageUri) =>
-          storageUri
-            .replace(
-              "supabase-storage://",
-              "https://supabase.example.com/storage/v1/object/sign/",
-            )
-            .replace(/([^:]\/)\/+/g, "$1"),
-        readStoredText,
-      ),
-      createTestStoragePlugin(
-        "gs",
-        (storageUri) =>
-          storageUri
-            .replace("gs://", "https://firebase.example.com/")
-            .replace(/([^:]\/)\/+/g, "$1"),
-        readStoredText,
-      ),
+    storage: [
+      createTestStoragePlugin("s3", readStoredText),
+      createTestStoragePlugin("r2", readStoredText),
+      createTestStoragePlugin("supabase-storage", readStoredText),
+      createTestStoragePlugin("gs", readStoredText),
     ],
   });
   const prismaSchemaHotUpdater = createHotUpdater({
@@ -331,7 +266,22 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
 
   it("uses the default generated schema artifact path for Drizzle", () => {
     const adapter = drizzleAdapter({
-      db: { _: { fullSchema: {} } },
+      db: {
+        _: {
+          fullSchema: {
+            bundle_patches: {},
+            bundles: {},
+          },
+        },
+        $count: vi.fn(),
+        delete: vi.fn(),
+        insert: vi.fn(),
+        query: {
+          bundle_patches: { findFirst: vi.fn(), findMany: vi.fn() },
+          bundles: { findFirst: vi.fn(), findMany: vi.fn() },
+        },
+        update: vi.fn(),
+      },
       provider: "sqlite",
     });
 
@@ -351,8 +301,11 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
 
   beforeEach(async () => {
     storageTexts.clear();
+    await db.exec("DELETE FROM release_catalogs");
+    await db.exec("DELETE FROM releases");
     await db.exec("DELETE FROM bundle_patches");
     await db.exec("DELETE FROM bundles");
+    await db.exec("DELETE FROM channels");
   });
 
   afterAll(async () => {
@@ -360,34 +313,20 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
     await db.close();
   });
 
-  const getUpdateInfo = async (
-    bundles: Bundle[],
-    options: GetBundlesArgs,
-  ): Promise<UpdateInfo | null> => {
-    // Insert fixtures via the server API to exercise its types + mapping
-    for (const b of bundles) {
-      await hotUpdater.insertBundle(b);
-    }
-    return hotUpdater.getUpdateInfo(options);
-  };
-
-  setupGetUpdateInfoTestSuite({ getUpdateInfo });
-  setupBundleMethodsTestSuite({
-    getBundleById: hotUpdater.getBundleById.bind(hotUpdater),
-    getChannels: hotUpdater.getChannels.bind(hotUpdater),
-    insertBundle: hotUpdater.insertBundle.bind(hotUpdater),
-    getBundles: hotUpdater.getBundles.bind(hotUpdater),
-    updateBundleById: hotUpdater.updateBundleById.bind(hotUpdater),
-    deleteBundleById: hotUpdater.deleteBundleById.bind(hotUpdater),
-  });
-
   describe("schema generation", () => {
     it("includes relations, defaults, and indexes in Prisma output", () => {
       const code = generateSchema(prismaSchemaHotUpdater, "latest").code;
 
-      expect(code).toContain('channel String @default("production")');
       expect(code).toContain('metadata Json @default("{}")');
-      expect(code).toContain('value String @default("0.31.0")');
+      expect(code).toContain('value String @default("1.0.0")');
+      expect(code).toContain("model channels {");
+      expect(code).toContain("id String @db.VarChar(255) @id");
+      expect(code).toContain("name String @db.VarChar(255)");
+      expect(code).toContain('@@unique([name], map: "channels_name_key")');
+      expect(code).toContain("channel_id String @db.VarChar(255)");
+      expect(code).toContain(
+        'channelRecord channels @relation("releases_channels", fields: [channel_id], references: [id], onUpdate: Restrict, onDelete: Restrict)',
+      );
       expect(code).toContain(
         'patches bundle_patches[] @relation("bundle_patches_bundles_patches")',
       );
@@ -400,7 +339,13 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
       expect(code).toContain(
         'baseBundle bundles @relation("bundle_patches_bundles_baseForPatches"',
       );
-      expect(code).toContain('@@index([channel], map: "bundles_channel_idx")');
+      expect(code).not.toContain(
+        '@@index([channel], map: "bundles_channel_idx")',
+      );
+      expect(code).toContain(
+        '@@index([scope_key, id], map: "releases_scope_order_idx")',
+      );
+      expect(code).toContain("scope_key String @db.VarChar(2048) @id");
       expect(code).not.toContain("bundles_platform_idx");
       expect(code).toContain(
         '@@index([bundle_id], map: "bundle_patches_bundle_id_idx")',
@@ -414,12 +359,10 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
       expect(code).not.toContain('metadata Json @default("{}")');
     });
 
-    it("generates ORM schema from the requested version snapshot", () => {
-      const code = generateSchema(prismaSchemaHotUpdater, "0.21.0").code;
-
-      expect(code).toContain('value String @default("0.21.0")');
-      expect(code).not.toContain("rollout_cohort_count");
-      expect(code).not.toContain("bundle_patches");
+    it("rejects generating a retired schema snapshot", () => {
+      expect(() => generateSchema(prismaSchemaHotUpdater, "0.21.0")).toThrow(
+        "Unsupported Hot Updater schema version: 0.21.0",
+      );
     });
 
     it("includes foreign keys and indexes in Drizzle output", () => {
@@ -431,36 +374,40 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
         /export const bundle_patches = [\s\S]*?(?=\n\nexport const bundle_patchesRelations = )/,
       )?.[0];
 
-      expect(code).toContain(
-        'channel: text("channel").notNull().default("production")',
-      );
       expect(code).toContain(
         'metadata: json("metadata").notNull().default({})',
       );
       expect(code).toContain('name: "bundle_patches_bundle_id_fk"');
       expect(code).toContain('name: "bundle_patches_base_bundle_id_fk"');
-      expect(bundlesBlock).toContain(
-        'index("bundles_channel_idx").on(table.channel)',
-      );
+      expect(code).toContain('.onDelete("cascade")');
+      expect(bundlesBlock).not.toContain("bundles_channel_idx");
       expect(bundlesBlock).not.toContain("bundles_platform_idx");
-      expect(bundlesBlock).toContain(
-        'index("bundles_target_app_version_idx").on(table.target_app_version)',
-      );
+      expect(bundlesBlock).not.toContain("target_app_version");
       expect(bundlesBlock).not.toContain(
         'index("bundle_patches_bundle_id_idx").on(table.bundle_id)',
       );
       expect(bundlePatchesBlock).toContain(
         'index("bundle_patches_bundle_id_idx").on(table.bundle_id)',
       );
-      expect(bundlePatchesBlock).not.toContain(
-        'index("bundles_target_app_version_idx").on(table.target_app_version)',
+      expect(code).toContain(
+        'index("releases_scope_order_idx").on(table.scope_key, table.id)',
+      );
+      expect(code).toContain(
+        'scope_key: varchar("scope_key", { length: 2048 }).primaryKey().notNull()',
       );
       const generatedCode = generateDrizzleSchema("postgresql");
       expect(generatedCode).toContain(
         'id: varchar("id", { length: 255 }).primaryKey().notNull()',
       );
       expect(generatedCode).toContain(
-        'version: varchar("version", { length: 255 }).notNull().default("0.31.0")',
+        'version: varchar("version", { length: 255 }).notNull().default("1.0.0")',
+      );
+      expect(generatedCode).toContain(
+        'uniqueIndex("channels_name_key").on(table.name)',
+      );
+      expect(generatedCode).toContain('name: "releases_channel_id_fk"');
+      expect(generatedCode).toContain(
+        'index("releases_channel_platform_order_idx").on(table.channel_id, table.platform, table.id)',
       );
       expect(generatedCode).not.toContain('key: varchar("key"');
       expect(generatedCode).not.toContain('value: text("value"');
@@ -468,46 +415,24 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
   });
 
   describe("migrator enhancements", () => {
-    it("derives incremental migrations from versioned schemas", () => {
+    it("registers only schema 1.0.0", () => {
       expect(hotUpdaterSchemaVersions.map((schema) => schema.version)).toEqual([
-        "0.21.0",
-        "0.29.0",
-        "0.31.0",
+        "1.0.0",
       ]);
-
-      const v029Sql = createSchemaMigrationSql(
-        "0.21.0",
-        "0.29.0",
-        "postgresql",
-      ).join("\n");
-      const v031Sql = createSchemaMigrationSql(
-        "0.29.0",
-        "0.31.0",
-        "postgresql",
-      ).join("\n");
-
-      expect(v029Sql).toContain(
-        "alter table bundles add column rollout_cohort_count",
-      );
-      expect(v029Sql).not.toContain("bundle_patches");
-      expect(v031Sql).toContain(
-        "alter table bundles add column manifest_storage_uri",
-      );
-      expect(v031Sql).toContain("create table if not exists bundle_patches");
-      expect(v031Sql).toContain(
-        "add constraint bundle_patches_bundle_id_fk foreign key",
-      );
     });
 
     it("omits MySQL defaults for text and JSON columns", () => {
       const sql = createTableSql("mysql").join("\n");
 
-      expect(sql).toContain("channel text not null");
-      expect(sql).not.toContain("channel text not null default");
+      expect(sql).toContain("create table channels");
       expect(sql).toContain("metadata json not null");
       expect(sql).not.toContain("metadata json not null default");
       expect(sql).toContain("`key` varchar(255) primary key");
       expect(sql).not.toContain("\nkey varchar(255) primary key");
+      expect(sql).toContain(
+        "create table api_keys (\nid varchar(255) primary key not null",
+      );
+      expect(sql).not.toContain("create table api_keys (\nid text primary key");
       expect(sql).toContain(
         "create index bundle_patches_bundle_id_idx on bundle_patches(bundle_id)",
       );
@@ -534,9 +459,11 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
         });
         const sql = result.getSQL?.() ?? "";
 
-        expect(sql).toContain("create index bundles_channel_idx on bundles");
         expect(sql).toContain(
-          "add constraint check_version_or_fingerprint check",
+          "create index releases_scope_order_idx on releases",
+        );
+        expect(sql).toContain(
+          "add constraint releases_strategy_target_check check",
         );
         expect(sql).toContain(
           "add constraint bundle_patches_bundle_id_fk foreign key",
@@ -558,7 +485,7 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
       }
     });
 
-    it("migrates existing 0.21.0 Kysely schemas incrementally", async () => {
+    it("rejects an existing v0 Kysely schema instead of upgrading it", async () => {
       const migrationDb = new PGlite();
       const migrationKysely = new Kysely<object>({
         dialect: new PGliteDialect(migrationDb),
@@ -572,20 +499,6 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
 
       try {
         await migrationDb.exec(`
-          create table bundles (
-            id uuid primary key,
-            platform text not null,
-            should_force_update boolean not null,
-            enabled boolean not null,
-            file_hash text not null,
-            git_commit_hash text,
-            message text,
-            channel text not null default 'production',
-            storage_uri text not null,
-            target_app_version text,
-            fingerprint_hash text,
-            metadata json not null default '{}'::json
-          );
           create table private_hot_updater_settings (
             key varchar(255) primary key,
             value text not null
@@ -595,31 +508,12 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
         `);
 
         const migrator = createMigrator(migrationHotUpdater);
-        const result = await migrator.migrateToLatest({
-          mode: "from-schema",
-          updateSettings: true,
-        });
-        const sql = result.getSQL?.() ?? "";
-
-        expect(sql).toContain(
-          "alter table bundles add column rollout_cohort_count",
-        );
-        expect(sql).toContain(
-          "alter table bundles add column manifest_storage_uri",
-        );
-        expect(sql).toContain("create table if not exists bundle_patches");
-        expect(sql).not.toContain("create table if not exists bundles");
-
-        await result.execute();
-
-        const version = await migrationDb.query<{ value: string }>(
-          "select value from private_hot_updater_settings where key = 'version'",
-        );
-        expect(version.rows[0]?.value).toBe("0.31.0");
-        await migrationDb.query(
-          "select rollout_cohort_count, target_cohorts, manifest_storage_uri from bundles limit 0",
-        );
-        await migrationDb.query("select * from bundle_patches limit 0");
+        await expect(
+          migrator.migrateToLatest({
+            mode: "from-schema",
+            updateSettings: true,
+          }),
+        ).rejects.toThrow("Hot Updater v1 cannot migrate schema 0.21.0");
       } finally {
         await migrationKysely.destroy();
         await migrationDb.close();
@@ -694,7 +588,10 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
 
     it("creates MongoDB indexes for runtime query fields", async () => {
       const collection = {
-        findOne: vi.fn(async () => null),
+        find: vi.fn(() => ({
+          limit: () => ({ toArray: async () => [] }),
+        })),
+        listIndexes: () => ({ toArray: async () => [] }),
       };
       const client = {
         db: () => ({
@@ -711,19 +608,28 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
       expect(result.operations).toEqual(
         expect.arrayContaining([
           expect.objectContaining({
-            sql: "create index bundles_id_idx on bundles(id)",
+            description:
+              "Create unique MongoDB index: bundles_id_idx on bundles(id)",
           }),
           expect.objectContaining({
-            sql: "create index bundles_target_app_version_idx on bundles(target_app_version)",
+            description:
+              "Create unique MongoDB index: bundle_patches_id_idx on bundle_patches(id)",
           }),
           expect.objectContaining({
-            sql: "create index bundles_fingerprint_hash_idx on bundles(fingerprint_hash)",
+            description:
+              "Create unique MongoDB index: release_catalogs_scope_key_idx on release_catalogs(scope_key)",
           }),
           expect.objectContaining({
-            sql: "create index bundles_platform_idx on bundles(platform)",
+            description:
+              "Create MongoDB index: releases_fingerprint_hash_idx on releases(fingerprint_hash)",
           }),
           expect.objectContaining({
-            sql: "create index bundle_patches_base_bundle_id_idx on bundle_patches(base_bundle_id)",
+            description:
+              "Create MongoDB index: bundles_platform_idx on bundles(platform)",
+          }),
+          expect.objectContaining({
+            description:
+              "Create MongoDB index: bundle_patches_base_bundle_id_idx on bundle_patches(base_bundle_id)",
           }),
         ]),
       );
@@ -802,7 +708,7 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
         `);
 
         await expect(migrationHotUpdater.getChannels()).rejects.toThrow(
-          "Hot Updater database schema version 0.21.0 is not supported by kysely.",
+          "Hot Updater v1 cannot migrate schema 0.21.0 in place.",
         );
       } finally {
         await migrationKysely.destroy();
@@ -812,7 +718,12 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
 
     it("rejects runtime access when a MongoDB schema is stale", async () => {
       const settings = {
-        findOne: vi.fn(async () => ({ key: "version", value: "0.21.0" })),
+        find: vi.fn(({ key }: { readonly key: string }) => ({
+          limit: () => ({
+            toArray: async () =>
+              key === "version" ? [{ key, value: "0.21.0" }] : [],
+          }),
+        })),
       };
       const bundles = {
         countDocuments: vi.fn(async () => 0),
@@ -836,7 +747,7 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
       });
 
       await expect(mongoHotUpdater.getBundles({ limit: 10 })).rejects.toThrow(
-        "Hot Updater database schema version 0.21.0 is not supported by mongodb.",
+        "Hot Updater v1 cannot migrate schema 0.21.0 in place.",
       );
       expect(bundles.countDocuments).not.toHaveBeenCalled();
     });
@@ -848,426 +759,84 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
         limit: 10,
         where: { id: { in: [] } },
       });
-      const byTargetAppVersion = await hotUpdater.getBundles({
-        limit: 10,
-        where: { targetAppVersionIn: [] },
-      });
-
       expect(byId.data).toEqual([]);
       expect(byId.pagination.total).toBe(0);
-      expect(byTargetAppVersion.data).toEqual([]);
-      expect(byTargetAppVersion.pagination.total).toBe(0);
-    });
-
-    it("combines Prisma targetAppVersion filters without overwriting", async () => {
-      const bundles = {
-        count: vi.fn(async () => 0),
-        createMany: vi.fn(),
-        deleteMany: vi.fn(),
-        findFirst: vi.fn(),
-        findMany: vi.fn(async () => []),
-        upsert: vi.fn(),
-      };
-      const patches = {
-        count: vi.fn(),
-        createMany: vi.fn(),
-        deleteMany: vi.fn(),
-        findFirst: vi.fn(),
-        findMany: vi.fn(async () => []),
-        upsert: vi.fn(),
-      };
-      const plugin = prismaAdapter({
-        prisma: { bundles, bundle_patches: patches },
-        provider: "postgresql",
-      })();
-
-      await plugin.getBundles({
-        limit: 10,
-        where: {
-          targetAppVersion: "1.0.x",
-          targetAppVersionNotNull: true,
-        },
-      });
-
-      expect(bundles.findMany).toHaveBeenCalledWith(
-        expect.objectContaining({
-          where: expect.objectContaining({
-            AND: [
-              { target_app_version: "1.0.x" },
-              { target_app_version: { not: null } },
-            ],
-          }),
-        }),
-      );
-    });
-
-    it("combines MongoDB targetAppVersion filters without overwriting", async () => {
-      const toArray = vi.fn(async () => []);
-      const limit = vi.fn(() => ({ toArray }));
-      const skip = vi.fn(() => ({ limit }));
-      const sort = vi.fn(() => ({ skip }));
-      const bundles = {
-        countDocuments: vi.fn(async () => 0),
-        distinct: vi.fn(),
-        find: vi.fn(() => ({ sort })),
-        findOne: vi.fn(),
-      };
-      const patches = {
-        deleteMany: vi.fn(),
-        find: vi.fn(() => ({
-          sort: vi.fn(() => ({ toArray: vi.fn(async () => []) })),
-        })),
-        insertMany: vi.fn(),
-      };
-      const client = {
-        db: () => ({
-          collection: (name: string) =>
-            name === "bundle_patches" ? patches : bundles,
-        }),
-      } as unknown as MongoClient;
-      const plugin = mongoAdapter({ client })();
-
-      await plugin.getBundles({
-        limit: 10,
-        where: {
-          targetAppVersion: "1.0.x",
-          targetAppVersionNotNull: true,
-        },
-      });
-
-      expect(bundles.countDocuments).toHaveBeenCalledWith({
-        $and: [
-          { target_app_version: "1.0.x" },
-          { target_app_version: { $exists: true, $nin: [null, ""] } },
-        ],
-      });
     });
 
-    it("uses Prisma update-check queries without generic list pagination", async () => {
-      const appVersionRow = bundleToRow(appVersionFastPathBundle);
-      const fingerprintRow = bundleToRow(fingerprintFastPathBundle);
-      const bundles = {
-        count: vi.fn(async () => {
-          throw new Error("unexpected generic Prisma count");
-        }),
-        createMany: vi.fn(),
-        deleteMany: vi.fn(),
-        findFirst: vi.fn(),
-        findMany: vi
-          .fn()
-          .mockResolvedValueOnce([
-            { target_app_version: appVersionRow.target_app_version },
-          ])
-          .mockResolvedValueOnce([appVersionRow])
-          .mockResolvedValueOnce([fingerprintRow]),
-        upsert: vi.fn(),
-      };
-      const patches = {
+    it("commits Prisma bundle changes inside a transaction when available", async () => {
+      const rootBundles = {
         count: vi.fn(),
-        createMany: vi.fn(),
+        create: vi.fn(),
         deleteMany: vi.fn(),
         findFirst: vi.fn(),
-        findMany: vi.fn(async () => []),
-        upsert: vi.fn(),
-      };
-      const plugin = prismaAdapter({
-        prisma: { bundles, bundle_patches: patches },
-        provider: "postgresql",
-      })();
-
-      await expect(
-        plugin.getUpdateInfo?.({
-          _updateStrategy: "appVersion",
-          appVersion: "1.0.0",
-          bundleId: NIL_UUID,
-          platform: "ios",
-        }),
-      ).resolves.toMatchObject({
-        id: appVersionFastPathBundle.id,
-        status: "UPDATE",
-      });
-      await expect(
-        plugin.getUpdateInfo?.({
-          _updateStrategy: "fingerprint",
-          bundleId: NIL_UUID,
-          fingerprintHash: "fingerprint-fast-path",
-          platform: "ios",
-        }),
-      ).resolves.toMatchObject({
-        id: fingerprintFastPathBundle.id,
-        status: "UPDATE",
-      });
-
-      expect(bundles.count).not.toHaveBeenCalled();
-      expect(bundles.findMany).toHaveBeenNthCalledWith(
-        1,
-        expect.objectContaining({
-          select: { target_app_version: true },
-          where: expect.objectContaining({
-            channel: "production",
-            id: { gte: NIL_UUID },
-          }),
-        }),
-      );
-      expect(bundles.findMany).toHaveBeenNthCalledWith(
-        2,
-        expect.objectContaining({
-          where: expect.objectContaining({
-            target_app_version: { in: ["1.0.0"] },
-          }),
-        }),
-      );
-      expect(bundles.findMany).toHaveBeenNthCalledWith(
-        3,
-        expect.objectContaining({
-          where: expect.objectContaining({
-            fingerprint_hash: "fingerprint-fast-path",
-          }),
-        }),
-      );
-      expect(patches.findMany).toHaveBeenCalledTimes(2);
-    });
-
-    it("uses Drizzle update-check queries without generic list pagination", async () => {
-      const appVersionRow = bundleToRow(appVersionFastPathBundle);
-      const fingerprintRow = bundleToRow(fingerprintFastPathBundle);
-      const tables = {
-        bundle_patches: {
-          bundle_id: "bundle_id",
-          id: "patch_id",
-          order_index: "order_index",
-        },
-        bundles: {
-          channel: "channel",
-          enabled: "enabled",
-          fingerprint_hash: "fingerprint_hash",
-          id: "id",
-          platform: "platform",
-          target_app_version: "target_app_version",
-        },
-      };
-      const bundleFindMany = vi
-        .fn()
-        .mockResolvedValueOnce([
-          { target_app_version: appVersionRow.target_app_version },
-        ])
-        .mockResolvedValueOnce([appVersionRow])
-        .mockResolvedValueOnce([fingerprintRow]);
-      const patchFindMany = vi.fn(async () => []);
-      const db = {
-        _: { fullSchema: tables },
-        $count: vi.fn(async () => {
-          throw new Error("unexpected generic Drizzle count");
-        }),
-        delete: vi.fn(() => ({
-          where: vi.fn(async () => undefined),
-        })),
-        insert: vi.fn(),
-        query: {
-          bundle_patches: {
-            findMany: patchFindMany,
-          },
-          bundles: {
-            findFirst: vi.fn(),
-            findMany: bundleFindMany,
-          },
-        },
-        select: vi.fn(),
+        findMany: vi.fn(),
         update: vi.fn(),
+        upsert: vi.fn(),
       };
-      const plugin = drizzleAdapter({
-        db,
-        provider: "postgresql",
-      })();
-
-      await expect(
-        plugin.getUpdateInfo?.({
-          _updateStrategy: "appVersion",
-          appVersion: "1.0.0",
-          bundleId: NIL_UUID,
-          platform: "ios",
-        }),
-      ).resolves.toMatchObject({
-        id: appVersionFastPathBundle.id,
-        status: "UPDATE",
-      });
-      await expect(
-        plugin.getUpdateInfo?.({
-          _updateStrategy: "fingerprint",
-          bundleId: NIL_UUID,
-          fingerprintHash: "fingerprint-fast-path",
-          platform: "ios",
-        }),
-      ).resolves.toMatchObject({
-        id: fingerprintFastPathBundle.id,
-        status: "UPDATE",
-      });
-
-      expect(db.$count).not.toHaveBeenCalled();
-      expect(bundleFindMany).toHaveBeenNthCalledWith(
-        1,
-        expect.objectContaining({
-          columns: { target_app_version: true },
-        }),
-      );
-      const appVersionWhere = JSON.stringify(bundleFindMany.mock.calls[0]?.[0]);
-      const fingerprintWhere = JSON.stringify(
-        bundleFindMany.mock.calls[2]?.[0],
-      );
-      expect(appVersionWhere).toContain("production");
-      expect(appVersionWhere).toContain(NIL_UUID);
-      expect(fingerprintWhere).toContain("production");
-      expect(fingerprintWhere).toContain(NIL_UUID);
-      expect(fingerprintWhere).toContain("fingerprint-fast-path");
-      expect(bundleFindMany).toHaveBeenCalledTimes(3);
-      expect(patchFindMany).toHaveBeenCalledTimes(2);
-    });
-
-    it("uses MongoDB update-check queries without generic list pagination", async () => {
-      const appVersionRow = bundleToRow(appVersionFastPathBundle);
-      const fingerprintRow = bundleToRow(fingerprintFastPathBundle);
-      const projectToArray = vi.fn(async () => [
-        { target_app_version: appVersionRow.target_app_version },
-      ]);
-      const sortToArray = vi
-        .fn()
-        .mockResolvedValueOnce([appVersionRow])
-        .mockResolvedValueOnce([fingerprintRow]);
-      const project = vi.fn(() => ({ toArray: projectToArray }));
-      const sort = vi.fn(() => ({ toArray: sortToArray }));
-      const bundles = {
-        countDocuments: vi.fn(async () => {
-          throw new Error("unexpected generic MongoDB count");
-        }),
-        deleteMany: vi.fn(),
-        distinct: vi.fn(),
-        find: vi.fn((filter: Record<string, unknown>) => {
-          const targetAppVersion = filter["target_app_version"];
-          if (
-            typeof targetAppVersion === "object" &&
-            targetAppVersion !== null &&
-            "$exists" in targetAppVersion
-          ) {
-            return { project };
-          }
-          return { sort };
-        }),
-        findOne: vi.fn(),
-        updateOne: vi.fn(),
-      };
-      const patches = {
-        deleteMany: vi.fn(),
-        find: vi.fn(() => ({
-          sort: vi.fn(() => ({ toArray: vi.fn(async () => []) })),
-        })),
-        insertMany: vi.fn(),
-      };
-      const client = {
-        db: () => ({
-          collection: (name: string) =>
-            name === "bundle_patches" ? patches : bundles,
-        }),
-      } as unknown as MongoClient;
-      const plugin = mongoAdapter({ client })();
-
-      await expect(
-        plugin.getUpdateInfo?.({
-          _updateStrategy: "appVersion",
-          appVersion: "1.0.0",
-          bundleId: NIL_UUID,
-          platform: "ios",
-        }),
-      ).resolves.toMatchObject({
-        id: appVersionFastPathBundle.id,
-        status: "UPDATE",
-      });
-      await expect(
-        plugin.getUpdateInfo?.({
-          _updateStrategy: "fingerprint",
-          bundleId: NIL_UUID,
-          fingerprintHash: "fingerprint-fast-path",
-          platform: "ios",
-        }),
-      ).resolves.toMatchObject({
-        id: fingerprintFastPathBundle.id,
-        status: "UPDATE",
-      });
-
-      expect(bundles.countDocuments).not.toHaveBeenCalled();
-      expect(bundles.find).toHaveBeenNthCalledWith(
-        1,
-        expect.objectContaining({
-          channel: "production",
-          id: { $gte: NIL_UUID },
-          target_app_version: { $exists: true, $nin: [null, ""] },
-        }),
-      );
-      expect(bundles.find).toHaveBeenNthCalledWith(
-        2,
-        expect.objectContaining({
-          target_app_version: { $in: ["1.0.0"] },
-        }),
-      );
-      expect(bundles.find).toHaveBeenNthCalledWith(
-        3,
-        expect.objectContaining({
-          fingerprint_hash: "fingerprint-fast-path",
-        }),
-      );
-      expect(patches.find).toHaveBeenCalledTimes(2);
-    });
-
-    it("commits Prisma bundle changes inside a transaction when available", async () => {
-      const rootBundles = {
+      const rootPatches = {
         count: vi.fn(),
-        createMany: vi.fn(),
+        create: vi.fn(),
         deleteMany: vi.fn(),
         findFirst: vi.fn(),
         findMany: vi.fn(),
+        update: vi.fn(),
         upsert: vi.fn(),
       };
-      const rootPatches = {
+      const channels = {
         count: vi.fn(),
-        createMany: vi.fn(),
+        create: vi.fn(),
         deleteMany: vi.fn(),
-        findFirst: vi.fn(),
+        findFirst: vi.fn(async () => ({
+          id: transactionChannelId,
+          name: "production",
+        })),
         findMany: vi.fn(),
+        update: vi.fn(),
         upsert: vi.fn(),
       };
       const txBundles = {
         ...rootBundles,
-        upsert: vi.fn(async () => undefined),
-      };
-      const txPatches = {
-        ...rootPatches,
-        deleteMany: vi.fn(async () => undefined),
+        create: vi.fn(async ({ data }) => data),
       };
+      const txPatches = { ...rootPatches };
       const $transaction = vi.fn(
         async (operation: (tx: Record<string, unknown>) => Promise<unknown>) =>
           operation({
             bundle_patches: txPatches,
             bundles: txBundles,
+            channels,
           }),
       );
-      const plugin = prismaAdapter({
+      const adapter = prismaAdapter({
         prisma: {
           $transaction,
           bundle_patches: rootPatches,
           bundles: rootBundles,
+          channels,
         },
         provider: "postgresql",
-      })();
+      });
 
-      await plugin.appendBundle(transactionBundle);
-      await plugin.commitBundle();
+      await adapter.commit({
+        changes: [
+          {
+            model: "bundles",
+            operation: "insert",
+            row: bundleToRow(transactionBundle),
+          },
+        ],
+      });
 
       expect($transaction).toHaveBeenCalledTimes(1);
-      expect(txBundles.upsert).toHaveBeenCalledTimes(1);
-      expect(rootBundles.upsert).not.toHaveBeenCalled();
+      expect(txBundles.create).toHaveBeenCalledTimes(1);
+      expect(rootBundles.create).not.toHaveBeenCalled();
     });
 
     it("commits Drizzle bundle changes inside a transaction when available", async () => {
       const tables = {
+        bundle_events: {
+          id: "event_id",
+        },
         bundle_patches: {
           bundle_id: "bundle_id",
           id: "patch_id",
@@ -1276,6 +845,20 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
         bundles: {
           id: "id",
         },
+        channels: {
+          id: sql.raw("channel_id"),
+          name: sql.raw("channel_name"),
+        },
+        api_keys: {
+          id: "access_key_id",
+        },
+        release_catalogs: {
+          scope_key: "scope_key",
+        },
+        releases: {
+          id: "release_id",
+          scope_key: "scope_key",
+        },
       };
       const rootInsert = vi.fn(() => ({
         values: vi.fn(() => ({ execute: vi.fn(async () => undefined) })),
@@ -1291,13 +874,37 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
         })),
         insert,
         query: {
+          bundle_events: {
+            findFirst: vi.fn(),
+            findMany: vi.fn(),
+          },
           bundle_patches: {
+            findFirst: vi.fn(),
             findMany: vi.fn(),
           },
           bundles: {
             findFirst: vi.fn(async () => undefined),
             findMany: vi.fn(),
           },
+          channels: {
+            findFirst: vi.fn(async () => ({
+              id: transactionChannelId,
+              name: "production",
+            })),
+            findMany: vi.fn(),
+          },
+          api_keys: {
+            findFirst: vi.fn(),
+            findMany: vi.fn(),
+          },
+          release_catalogs: {
+            findFirst: vi.fn(),
+            findMany: vi.fn(),
+          },
+          releases: {
+            findFirst: vi.fn(),
+            findMany: vi.fn(),
+          },
         },
         select: vi.fn(),
         update: vi.fn(() => ({
@@ -1315,26 +922,27 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
         ...createDb(rootInsert),
         transaction,
       };
-      const plugin = drizzleAdapter({
+      const adapter = drizzleAdapter({
         db,
         provider: "postgresql",
-      })();
+      });
 
-      await plugin.appendBundle(transactionBundle);
-      await plugin.commitBundle();
+      await adapter.commit({
+        changes: [
+          {
+            model: "bundles",
+            operation: "insert",
+            row: bundleToRow(transactionBundle),
+          },
+        ],
+      });
 
       expect(transaction).toHaveBeenCalledTimes(1);
       expect(txInsert).toHaveBeenCalledTimes(1);
       expect(rootInsert).not.toHaveBeenCalled();
     });
 
-    it("commits MongoDB bundle changes inside a session transaction when available", async () => {
-      const session = {
-        endSession: vi.fn(async () => undefined),
-        withTransaction: vi.fn(async (operation: () => Promise<void>) =>
-          operation(),
-        ),
-      };
+    it("does not expose an implicit MongoDB transaction", () => {
       const bundles = {
         countDocuments: vi.fn(),
         deleteMany: vi.fn(),
@@ -1353,64 +961,69 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
           collection: (name: string) =>
             name === "bundle_patches" ? patches : bundles,
         }),
-        startSession: vi.fn(() => session),
       } as unknown as MongoClient;
-      const plugin = mongoAdapter({ client })();
+      const adapter = mongoAdapter({ client });
 
-      await plugin.appendBundle(transactionBundle);
-      await plugin.commitBundle();
-
-      expect(client.startSession).toHaveBeenCalledTimes(1);
-      expect(session.withTransaction).toHaveBeenCalledTimes(1);
-      expect(bundles.updateOne).toHaveBeenCalledWith(
-        { id: transactionBundle.id },
-        expect.any(Object),
-        expect.objectContaining({ session, upsert: true }),
-      );
-      expect(patches.deleteMany).toHaveBeenCalledWith(
-        { bundle_id: transactionBundle.id },
-        { session },
-      );
-      expect(session.endSession).toHaveBeenCalledTimes(1);
+      expect(Reflect.has(adapter, "transaction")).toBe(false);
     });
-  });
 
-  describe("bundle validation", () => {
-    it("rejects bundles without targeting information", async () => {
-      await expect(
-        hotUpdater.insertBundle({
-          id: "00000000-0000-0000-0000-000000000999",
-          platform: "ios",
-          shouldForceUpdate: false,
-          enabled: true,
-          fileHash: "missing-target",
-          gitCommitHash: null,
-          message: null,
-          channel: "production",
-          storageUri: "s3://test-bucket/missing-target.zip",
-          targetAppVersion: null,
-          fingerprintHash: null,
+    it("uses a MongoDB session when transactions are enabled", async () => {
+      const client = new MongoClient("mongodb://localhost");
+      const session = client.startSession();
+      const withTransaction = vi.fn(
+        async (operation: (session: ClientSession) => Promise<unknown>) =>
+          operation(session),
+      );
+      Object.defineProperty(session, "withTransaction", {
+        value: withTransaction,
+      });
+      const insertOne = vi.fn(async () => undefined);
+      Object.defineProperty(client, "db", {
+        value: () => ({
+          collection: () => ({
+            findOne: vi.fn(async () => ({
+              id: transactionChannelId,
+              name: "production",
+            })),
+            insertOne,
+            updateOne: vi.fn(async () => ({ matchedCount: 1 })),
+          }),
         }),
-      ).rejects.toThrow(
-        "Bundle must define either targetAppVersion or fingerprintHash.",
+      });
+      const withSession = vi.fn(
+        async (operation: (session: ClientSession) => Promise<unknown>) =>
+          operation(session),
       );
+      Object.defineProperty(client, "withSession", { value: withSession });
+      const adapter = mongoAdapter({ client, transactions: true });
+
+      await adapter.commit({
+        changes: [
+          {
+            model: "bundles",
+            operation: "insert",
+            row: bundleToRow(transactionBundle),
+          },
+        ],
+      });
+
+      expect(withSession).toHaveBeenCalledTimes(1);
+      expect(withTransaction).toHaveBeenCalledTimes(1);
+      expect(insertOne).toHaveBeenCalledWith(bundleToRow(transactionBundle), {
+        session,
+      });
     });
   });
 
   describe("getBundleById", () => {
     it("should retrieve bundle by id without Prisma validation errors", async () => {
       const bundle: Bundle = {
+        archiveByteSize: 1_024,
         id: "00000000-0000-0000-0000-000000000010",
         platform: "ios",
-        shouldForceUpdate: false,
-        enabled: true,
         fileHash: "test-hash",
         gitCommitHash: null,
-        message: "Test bundle for getBundleById",
-        channel: "production",
         storageUri: "s3://test-bucket/test.zip",
-        targetAppVersion: "1.0.0",
-        fingerprintHash: null,
       };
 
       await hotUpdater.insertBundle(bundle);
@@ -1434,59 +1047,23 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
   });
 
   describe("getChannels", () => {
-    it("should retrieve all unique channels without Prisma validation errors", async () => {
-      const bundles: Bundle[] = [
-        {
-          id: "00000000-0000-0000-0000-000000000020",
-          platform: "ios",
-          shouldForceUpdate: false,
-          enabled: true,
-          fileHash: "hash1",
-          gitCommitHash: null,
-          message: "Bundle 1",
-          channel: "production",
-          storageUri: "s3://test/1.zip",
-          targetAppVersion: "1.0.0",
-          fingerprintHash: null,
-        },
-        {
-          id: "00000000-0000-0000-0000-000000000021",
-          platform: "android",
-          shouldForceUpdate: false,
-          enabled: true,
-          fileHash: "hash2",
-          gitCommitHash: null,
-          message: "Bundle 2",
-          channel: "staging",
-          storageUri: "s3://test/2.zip",
-          targetAppVersion: "1.0.0",
-          fingerprintHash: null,
-        },
-        {
-          id: "00000000-0000-0000-0000-000000000022",
-          platform: "ios",
-          shouldForceUpdate: false,
-          enabled: true,
-          fileHash: "hash3",
-          gitCommitHash: null,
-          message: "Bundle 3",
-          channel: "production",
-          storageUri: "s3://test/3.zip",
-          targetAppVersion: "1.0.0",
-          fingerprintHash: null,
-        },
-      ];
-
-      for (const bundle of bundles) {
-        await hotUpdater.insertBundle(bundle);
-      }
+    it("retrieves canonical Channel rows without Prisma validation errors", async () => {
+      await hotUpdater.insertChannel({
+        onConflict: "returnExisting",
+        row: { id: "channel-production", name: "production" },
+      });
+      await hotUpdater.insertChannel({
+        onConflict: "returnExisting",
+        row: { id: "channel-staging", name: "staging" },
+      });
 
-      // This should not throw a Prisma validation error
       const channels = await hotUpdater.getChannels();
 
       expect(channels).toHaveLength(2);
-      expect(channels).toContain("production");
-      expect(channels).toContain("staging");
+      expect(channels.map(({ name }) => name)).toEqual([
+        "production",
+        "staging",
+      ]);
     });
 
     it("should return empty array when no bundles exist", async () => {
@@ -1495,7 +1072,7 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
     });
   });
 
-  describe("getAppUpdateInfo with storage plugins", () => {
+  describe("getArtifactInfo with storage plugins", () => {
     beforeEach(() => {
       // Fix time for deterministic signed URLs
       vi.useFakeTimers();
@@ -1508,27 +1085,17 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
 
     it("resolves s3:// storage URI to signed URL via s3StoragePlugin", async () => {
       const bundle: Bundle = {
+        archiveByteSize: 1_024,
         id: "00000000-0000-0000-0000-000000000001",
         platform: "ios",
-        shouldForceUpdate: false,
-        enabled: true,
         fileHash: "hash123",
         gitCommitHash: null,
-        message: "Test bundle",
-        channel: "production",
         storageUri: "s3://test-bucket/bundles/bundle.zip",
-        targetAppVersion: "1.0.0",
-        fingerprintHash: null,
       };
 
       await hotUpdater.insertBundle(bundle);
 
-      const updateInfo = await hotUpdater.getAppUpdateInfo({
-        appVersion: "1.0.0",
-        bundleId: NIL_UUID,
-        platform: "ios",
-        _updateStrategy: "appVersion",
-      });
+      const updateInfo = await hotUpdater.getArtifactInfo(bundle.id, NIL_UUID);
 
       expect(updateInfo).not.toBeNull();
       expect(updateInfo?.fileUrl).toBe(
@@ -1536,173 +1103,59 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
       );
     });
 
-    it("passes through http:// URLs without plugin resolution", async () => {
-      const bundle: Bundle = {
-        id: "00000000-0000-0000-0000-000000000004",
-        platform: "ios",
-        shouldForceUpdate: false,
-        enabled: true,
-        fileHash: "hashhttp",
-        gitCommitHash: null,
-        message: "HTTP bundle",
-        channel: "production",
-        storageUri: "s3://bundle/bundle.zip",
-        targetAppVersion: "1.0.0",
-        fingerprintHash: null,
-      };
-
-      await hotUpdater.insertBundle(bundle);
-
-      const updateInfo = await hotUpdater.getAppUpdateInfo({
-        appVersion: "1.0.0",
-        bundleId: NIL_UUID,
-        platform: "ios",
-        _updateStrategy: "appVersion",
-      });
-
-      expect(updateInfo).not.toBeNull();
-      expect(updateInfo?.fileUrl).toBe(
-        "https://s3.example.com/bundle/bundle.zip",
-      );
-    });
-
-    it("passes through https:// URLs without plugin resolution", async () => {
-      const bundle: Bundle = {
-        id: "00000000-0000-0000-0000-000000000005",
-        platform: "ios",
-        shouldForceUpdate: false,
-        enabled: true,
-        fileHash: "hashhttps",
-        gitCommitHash: null,
-        message: "HTTPS bundle",
-        channel: "production",
-        storageUri: "https://cdn.example.com/bundle.zip",
-        targetAppVersion: "1.0.0",
-        fingerprintHash: null,
-      };
-
-      await hotUpdater.insertBundle(bundle);
-
-      const updateInfo = await hotUpdater.getAppUpdateInfo({
-        appVersion: "1.0.0",
-        bundleId: NIL_UUID,
-        platform: "ios",
-        _updateStrategy: "appVersion",
-      });
-
-      expect(updateInfo).not.toBeNull();
-      expect(updateInfo?.fileUrl).toBe("https://cdn.example.com/bundle.zip");
-    });
-
-    it("returns null when no update is available", async () => {
-      const updateInfo = await hotUpdater.getAppUpdateInfo({
-        appVersion: "99.0.0",
-        bundleId: NIL_UUID,
-        platform: "ios",
-        _updateStrategy: "appVersion",
-      });
-
-      expect(updateInfo).toBeNull();
-    });
-
-    it("works with fingerprint strategy", async () => {
-      const bundle: Bundle = {
-        id: "00000000-0000-0000-0000-000000000008",
-        platform: "ios",
-        shouldForceUpdate: false,
-        enabled: true,
-        fileHash: "hashfp",
-        gitCommitHash: null,
-        message: "Fingerprint bundle",
-        channel: "production",
-        storageUri: "s3://test-bucket/fp-bundle.zip",
-        targetAppVersion: null,
-        fingerprintHash: "fingerprint123",
-      };
-
-      await hotUpdater.insertBundle(bundle);
-
-      const updateInfo = await hotUpdater.getAppUpdateInfo({
-        fingerprintHash: "fingerprint123",
-        bundleId: NIL_UUID,
-        platform: "ios",
-        _updateStrategy: "fingerprint",
-      });
-
-      expect(updateInfo).not.toBeNull();
-      expect(updateInfo?.fileUrl).toBe(
-        "https://s3.example.com/test-bucket/fp-bundle.zip",
-      );
-    });
-
-    it("returns manifest metadata and hbc patch descriptors for createHotUpdater", async () => {
+    it("returns manifest metadata and hbc patch descriptors", async () => {
       const currentManifestStorageUri =
-        "s3://test-bucket/releases/00000000-0000-0000-0000-000000000101/manifest.json";
+        "s3://test-bucket/releases/bundles/00000000-0000-0000-0000-000000000101/manifest.json";
       const nextManifestStorageUri =
-        "s3://test-bucket/releases/00000000-0000-0000-0000-000000000102/manifest.json";
+        "s3://test-bucket/releases/bundles/00000000-0000-0000-0000-000000000102/manifest.json";
       const olderBundle: Bundle = {
+        archiveByteSize: 1_024,
         id: "00000000-0000-0000-0000-000000000100",
         platform: "ios",
-        shouldForceUpdate: false,
-        enabled: true,
         fileHash: "hash-older-zip",
         gitCommitHash: null,
-        message: "Older bundle",
-        channel: "production",
         storageUri:
-          "s3://test-bucket/releases/00000000-0000-0000-0000-000000000100/bundle.zip",
-        targetAppVersion: "1.0.0",
-        fingerprintHash: null,
+          "s3://test-bucket/releases/bundles/00000000-0000-0000-0000-000000000100/bundle.zip",
       };
       const currentBundle: Bundle = {
+        archiveByteSize: 1_024,
         id: "00000000-0000-0000-0000-000000000101",
         platform: "ios",
-        shouldForceUpdate: false,
-        enabled: true,
         fileHash: "hash-current-zip",
         gitCommitHash: null,
-        message: "Current bundle",
-        channel: "production",
         storageUri:
-          "s3://test-bucket/releases/00000000-0000-0000-0000-000000000101/bundle.zip",
-        targetAppVersion: "1.0.0",
-        fingerprintHash: null,
-        assetBaseStorageUri:
-          "s3://test-bucket/releases/00000000-0000-0000-0000-000000000101/files",
+          "s3://test-bucket/releases/bundles/00000000-0000-0000-0000-000000000101/bundle.zip",
+        assetBaseStorageUri: "s3://test-bucket/releases/assets",
         manifestFileHash: "sig:manifest-current",
         manifestStorageUri: currentManifestStorageUri,
       };
       const nextBundle: Bundle = {
+        archiveByteSize: 1_024,
         id: "00000000-0000-0000-0000-000000000102",
         platform: "ios",
-        shouldForceUpdate: false,
-        enabled: true,
         fileHash: "hash-next-zip",
         gitCommitHash: null,
-        message: "Next bundle",
-        channel: "production",
         storageUri:
-          "s3://test-bucket/releases/00000000-0000-0000-0000-000000000102/bundle.zip",
-        targetAppVersion: "1.0.0",
-        fingerprintHash: null,
-        assetBaseStorageUri:
-          "s3://test-bucket/releases/00000000-0000-0000-0000-000000000102/files",
+          "s3://test-bucket/releases/bundles/00000000-0000-0000-0000-000000000102/bundle.zip",
+        assetBaseStorageUri: "s3://test-bucket/releases/assets",
         manifestFileHash: "sig:manifest-next",
         manifestStorageUri: nextManifestStorageUri,
         patches: [
           {
             baseBundleId: "00000000-0000-0000-0000-000000000100",
             baseFileHash: "hash-older-bundle",
+            byteSize: 48,
             patchFileHash: "hash-older-bsdiff",
             patchStorageUri:
-              "s3://test-bucket/releases/00000000-0000-0000-0000-000000000102/patches/00000000-0000-0000-0000-000000000100/index.ios.bundle.bsdiff",
+              "s3://test-bucket/releases/bundles/00000000-0000-0000-0000-000000000102/patches/00000000-0000-0000-0000-000000000100/index.ios.bundle.bsdiff",
           },
           {
             baseBundleId: currentBundle.id,
             baseFileHash: "hash-old-bundle",
+            byteSize: 48,
             patchFileHash: "hash-bsdiff",
             patchStorageUri:
-              "s3://test-bucket/releases/00000000-0000-0000-0000-000000000102/patches/00000000-0000-0000-0000-000000000101/index.ios.bundle.bsdiff",
+              "s3://test-bucket/releases/bundles/00000000-0000-0000-0000-000000000102/patches/00000000-0000-0000-0000-000000000101/index.ios.bundle.bsdiff",
           },
         ],
       };
@@ -1747,19 +1200,13 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
 
       try {
         await expect(
-          hotUpdater.getAppUpdateInfo({
-            appVersion: "1.0.0",
-            bundleId: currentBundle.id,
-            channel: "production",
-            platform: "ios",
-            _updateStrategy: "appVersion",
-          }),
+          hotUpdater.getArtifactInfo(nextBundle.id, currentBundle.id),
         ).resolves.toEqual({
           changedAssets: {
             "index.ios.bundle": {
               file: {
                 compression: "br",
-                url: "https://s3.example.com/test-bucket/releases/00000000-0000-0000-0000-000000000102/files/index.ios.bundle.br",
+                url: "https://s3.example.com/test-bucket/releases/assets/sha256/ha/hash-new-bundle.br",
               },
               fileHash: "hash-new-bundle",
               patch: {
@@ -1768,20 +1215,16 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
                 baseFileHash: "hash-old-bundle",
                 patchFileHash: "hash-bsdiff",
                 patchUrl:
-                  "https://s3.example.com/test-bucket/releases/00000000-0000-0000-0000-000000000102/patches/00000000-0000-0000-0000-000000000101/index.ios.bundle.bsdiff",
+                  "https://s3.example.com/test-bucket/releases/bundles/00000000-0000-0000-0000-000000000102/patches/00000000-0000-0000-0000-000000000101/index.ios.bundle.bsdiff",
               },
             },
           },
           fileHash: "hash-next-zip",
           fileUrl:
-            "https://s3.example.com/test-bucket/releases/00000000-0000-0000-0000-000000000102/bundle.zip",
-          id: nextBundle.id,
+            "https://s3.example.com/test-bucket/releases/bundles/00000000-0000-0000-0000-000000000102/bundle.zip",
           manifestFileHash: "sig:manifest-next",
           manifestUrl:
-            "https://s3.example.com/test-bucket/releases/00000000-0000-0000-0000-000000000102/manifest.json",
-          message: "Next bundle",
-          shouldForceUpdate: false,
-          status: "UPDATE",
+            "https://s3.example.com/test-bucket/releases/bundles/00000000-0000-0000-0000-000000000102/manifest.json",
         });
         expect(fetchMock).not.toHaveBeenCalled();
       } finally {
@@ -1789,24 +1232,18 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
       }
     });
 
-    it("propagates manifest storage read failures for createHotUpdater", async () => {
+    it("propagates manifest storage read failures", async () => {
       const nextManifestStorageUri =
-        "s3://test-bucket/releases/00000000-0000-0000-0000-000000000109/manifest.json";
+        "s3://test-bucket/releases/bundles/00000000-0000-0000-0000-000000000109/manifest.json";
       const nextBundle: Bundle = {
+        archiveByteSize: 1_024,
         id: "00000000-0000-0000-0000-000000000109",
         platform: "ios",
-        shouldForceUpdate: false,
-        enabled: true,
         fileHash: "hash-next-zip",
         gitCommitHash: null,
-        message: "Next bundle",
-        channel: "production",
         storageUri:
-          "s3://test-bucket/releases/00000000-0000-0000-0000-000000000109/bundle.zip",
-        targetAppVersion: "1.0.0",
-        fingerprintHash: null,
-        assetBaseStorageUri:
-          "s3://test-bucket/releases/00000000-0000-0000-0000-000000000109/files",
+          "s3://test-bucket/releases/bundles/00000000-0000-0000-0000-000000000109/bundle.zip",
+        assetBaseStorageUri: "s3://test-bucket/releases/assets",
         manifestFileHash: "sig:manifest-next",
         manifestStorageUri: nextManifestStorageUri,
       };
@@ -1818,137 +1255,8 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
       );
 
       await expect(
-        hotUpdater.getAppUpdateInfo({
-          appVersion: "1.0.0",
-          bundleId: NIL_UUID,
-          channel: "production",
-          platform: "ios",
-          _updateStrategy: "appVersion",
-        }),
+        hotUpdater.getArtifactInfo(nextBundle.id, NIL_UUID),
       ).rejects.toThrow("storage read failed");
     });
   });
-
-  describe("database plugin factories", () => {
-    it("keeps optional maintenance capabilities lazy", () => {
-      const factory = vi.fn(() => ({
-        async getBundleById() {
-          return null;
-        },
-        async getBundles() {
-          return {
-            data: [],
-            pagination: {
-              hasNextPage: false,
-              hasPreviousPage: false,
-              currentPage: 1,
-              totalPages: 1,
-              total: 0,
-            },
-          };
-        },
-        async getChannels() {
-          return [];
-        },
-        async commitBundle() {},
-      }));
-      createHotUpdater({
-        database: createDatabasePlugin({
-          name: "lazyPlugin",
-          factory,
-        })({}),
-      });
-
-      expect(factory).not.toHaveBeenCalled();
-    });
-
-    it("isolates pending mutation state between overlapping writes", async () => {
-      const committedBundleIds: string[][] = [];
-      const onUnmount = vi.fn(async () => undefined);
-      let releaseFirstCommit!: () => void;
-      let notifyFirstCommitStarted!: () => void;
-      const firstCommitStarted = new Promise<void>((resolve) => {
-        notifyFirstCommitStarted = resolve;
-      });
-      const firstCommitGate = new Promise<void>((resolve) => {
-        releaseFirstCommit = resolve;
-      });
-      let commitCount = 0;
-
-      const isolatedHotUpdater = createHotUpdater({
-        database: createDatabasePlugin({
-          name: "isolatedPlugin",
-          factory: () => ({
-            async getBundleById() {
-              return null;
-            },
-            async getBundles() {
-              return {
-                data: [],
-                pagination: {
-                  hasNextPage: false,
-                  hasPreviousPage: false,
-                  currentPage: 1,
-                  totalPages: 1,
-                  total: 0,
-                },
-              };
-            },
-            async getChannels() {
-              return [];
-            },
-            onUnmount,
-            async commitBundle({ changedSets }) {
-              commitCount += 1;
-              committedBundleIds.push(
-                changedSets.map((change) => change.data.id),
-              );
-
-              if (commitCount === 1) {
-                notifyFirstCommitStarted();
-                await firstCommitGate;
-              }
-            },
-          }),
-        })({}),
-      });
-
-      const firstBundleId = "00000000-0000-0000-0000-000000000030";
-      const secondBundleId = "00000000-0000-0000-0000-000000000031";
-
-      const firstInsert = isolatedHotUpdater.insertBundle({
-        id: firstBundleId,
-        platform: "ios",
-        shouldForceUpdate: false,
-        enabled: true,
-        fileHash: "hash-1",
-        gitCommitHash: null,
-        message: "first bundle",
-        channel: "production",
-        storageUri: "s3://test-bucket/first.zip",
-        targetAppVersion: "1.0.0",
-        fingerprintHash: null,
-      });
-      await firstCommitStarted;
-
-      const secondInsert = isolatedHotUpdater.insertBundle({
-        id: secondBundleId,
-        platform: "ios",
-        shouldForceUpdate: false,
-        enabled: true,
-        fileHash: "hash-2",
-        gitCommitHash: null,
-        message: "second bundle",
-        channel: "production",
-        storageUri: "s3://test-bucket/second.zip",
-        targetAppVersion: "1.0.0",
-        fingerprintHash: null,
-      });
-
-      releaseFirstCommit();
-      await Promise.all([firstInsert, secondInsert]);
-
-      expect(committedBundleIds).toEqual([[firstBundleId], [secondBundleId]]);
-    });
-  });
 });