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

package/src/database/sql/sqlSchema.ts

@@ -1,286 +0,0 @@
-import {
-  DatabaseSchemaError,
-  findPhysicalColumn,
-  indexOrderColumns,
-  type PhysicalColumn,
-  type PhysicalIndex,
-  type PhysicalTable,
-} from "@hot-updater/plugin-core/internal";
-
-export type SqlDialect = "postgresql" | "mysql" | "sqlite";
-
-/** Quotes an identifier: backticks on MySQL, double quotes elsewhere. */
-export const quoteSql = (dialect: SqlDialect, name: string) =>
-  dialect === "mysql"
-    ? `\`${name.replaceAll("`", "``")}\``
-    : `"${name.replaceAll('"', '""')}"`;
-
-export const isMultiIndex = (table: PhysicalTable, index: PhysicalIndex) =>
-  index.eq.some((column) => findPhysicalColumn(table, column).multi);
-
-/** Keeps an identifier within PostgreSQL's 63 and MySQL's 64 characters. */
-export const shortSqlName = (name: string) => {
-  if (name.length <= 60) return name;
-  let hash = 0x811c9dc5;
-  for (const char of name)
-    hash = Math.imul(hash ^ char.charCodeAt(0), 0x01000193) >>> 0;
-  return `${name.slice(0, 51)}_${hash.toString(36)}`;
-};
-
-/** The column type; `entry` types one value of a multi-valued column in its index table. */
-const columnType = (
-  dialect: SqlDialect,
-  column: PhysicalColumn,
-  indexed: boolean,
-  entry = false,
-): string => {
-  if ((column.multi && !entry) || column.type === "json") {
-    return { postgresql: "jsonb", mysql: "json", sqlite: "TEXT" }[dialect];
-  }
-  if (column.type === "string") {
-    const length = column.maxLength ?? (indexed ? 255 : undefined);
-    if (dialect === "sqlite") return "TEXT";
-    if (dialect === "postgresql") {
-      return `${column.maxLength ? `varchar(${column.maxLength})` : "text"} COLLATE "C"`;
-    }
-    const charset = column.ascii
-      ? "ascii COLLATE ascii_bin"
-      : "utf8mb4 COLLATE utf8mb4_0900_bin";
-    return `${length ? `varchar(${length})` : "longtext"} CHARACTER SET ${charset}`;
-  }
-  if (column.type === "integer")
-    return dialect === "sqlite" ? "INTEGER" : "bigint";
-  if (column.type === "number") {
-    return { postgresql: "double precision", mysql: "double", sqlite: "REAL" }[
-      dialect
-    ];
-  }
-  return dialect === "sqlite" ? "INTEGER" : "boolean";
-};
-
-/** InnoDB's limit on the bytes of one key or index. */
-const MYSQL_KEY_BYTES = 3072;
-
-/** Refuses a MySQL key or index over InnoDB's limit before any DDL runs. */
-const checkMysqlKey = (
-  table: PhysicalTable,
-  name: string,
-  columns: readonly string[],
-) => {
-  const bytes = columns.reduce((sum, column) => {
-    const { type, maxLength, ascii } = findPhysicalColumn(table, column);
-    if (type === "string") return sum + (maxLength ?? 255) * (ascii ? 1 : 4);
-    return sum + (type === "boolean" ? 1 : 8);
-  }, 0);
-  if (bytes > MYSQL_KEY_BYTES) {
-    throw new DatabaseSchemaError(
-      `${table.name} ${name} needs ${bytes} bytes on MySQL, over its ${MYSQL_KEY_BYTES}; shorten its strings or mark ASCII ones ascii.`,
-    );
-  }
-};
-
-export interface SqlColumnShape {
-  readonly name: string;
-  /** The column's DDL type, collation included. */
-  readonly type: string;
-  readonly notNull: boolean;
-  readonly default?: number;
-}
-
-export interface SqlTableShape {
-  readonly name: string;
-  readonly columns: readonly SqlColumnShape[];
-  readonly key: readonly string[];
-  /** Indexes, and index tables for multi-valued fields, in declaration order. */
-  readonly indexes: readonly (
-    | {
-        readonly kind: "index";
-        readonly name: string;
-        readonly unique: boolean;
-        readonly columns: readonly string[];
-      }
-    | { readonly kind: "table"; readonly table: SqlTableShape }
-  )[];
-}
-
-/**
- * Each table as the DDL creates it, for the DDL below and for ORM schema
- * generators: binary collation, one index per declared index, and an index
- * table `<table>__<index>` for each index over a multi-valued field, keyed by
- * every column it holds.
- */
-export const sqlTableShapes = (
-  dialect: SqlDialect,
-  tables: readonly PhysicalTable[],
-  tablePrefix = "",
-): SqlTableShape[] =>
-  tables.map((table) => {
-    const name = tablePrefix + table.name;
-    const indexed = new Set([
-      ...table.key,
-      ...table.indexes.flatMap(({ eq, sort }) => [...eq, ...sort]),
-    ]);
-    if (dialect === "mysql") checkMysqlKey(table, "key", table.key);
-    const indexes = table.indexes.flatMap((index): SqlTableShape["indexes"] => {
-      const columns = [...index.eq, ...indexOrderColumns(table, index)];
-      if (dialect === "mysql") {
-        checkMysqlKey(table, `index ${index.name}`, columns);
-      }
-      if (isMultiIndex(table, index)) {
-        const entries = columns.map((column) => ({
-          name: column,
-          type: columnType(
-            dialect,
-            findPhysicalColumn(table, column),
-            true,
-            true,
-          ),
-          notNull: true,
-        }));
-        const indexTable = {
-          name: `${name}__${index.name}`,
-          columns: entries,
-          key: columns,
-          indexes: [],
-        };
-        return [{ kind: "table", table: indexTable }];
-      }
-      if (!index.unique && columns.join() === table.key.join()) return [];
-      return [
-        {
-          kind: "index",
-          name: shortSqlName(`${name}_${index.name}`),
-          unique: index.unique === true,
-          columns: index.unique ? index.eq : columns,
-        },
-      ];
-    });
-    // 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) => ({
-        name: column.name,
-        type: columnType(dialect, column, indexed.has(column.name)),
-        notNull: !column.nullable,
-        ...(column.default === undefined ? {} : { default: column.default }),
-      })),
-      key: table.key,
-      indexes,
-    };
-  });
-
-/** DDL for the tables' shapes: each table, then its indexes and index tables. */
-export const createTableStatements = (
-  dialect: SqlDialect,
-  tables: readonly PhysicalTable[],
-  tablePrefix = "",
-): string[] => {
-  const quote = (name: string) => quoteSql(dialect, name);
-  const list = (columns: readonly string[]) => columns.map(quote).join(", ");
-  const render = (shape: SqlTableShape): string[] => {
-    const definitions = shape.columns.map(
-      (column) =>
-        `${quote(column.name)} ${column.type}${column.notNull ? " NOT NULL" : ""}${column.default === undefined ? "" : ` DEFAULT ${column.default}`}`,
-    );
-    definitions.push(`PRIMARY KEY (${list(shape.key)})`);
-    const after: string[] = [];
-    for (const index of shape.indexes) {
-      if (index.kind === "table") {
-        after.push(...render(index.table));
-      } else if (dialect === "mysql") {
-        definitions.push(
-          `${index.unique ? "UNIQUE " : ""}INDEX ${quote(index.name)} (${list(index.columns)})`,
-        );
-      } else {
-        after.push(
-          `CREATE ${index.unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${quote(index.name)} ON ${quote(shape.name)} (${list(index.columns)})`,
-        );
-      }
-    }
-    return [
-      `CREATE TABLE IF NOT EXISTS ${quote(shape.name)} (${definitions.join(", ")})`,
-      ...after,
-    ];
-  };
-  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/database/sql/sqlTestExecutors.ts

@@ -1,183 +0,0 @@
-import type { DatabaseSync, SqliteValue } from "node:sqlite";
-
-import type { PGlite } from "@electric-sql/pglite";
-import type { Pool as MysqlPool, PoolConnection } from "mysql2/promise";
-import type { Pool as PgPool, PoolClient } from "pg";
-
-import type {
-  SqlConnection,
-  SqlExecutor,
-  SqlResult,
-  SqlStatement,
-} from "./sqlAdapter";
-
-/** Test executors for the SQL core; provider executors arrive with D1–D3. */
-
-export const pgliteExecutor = (db: PGlite): SqlExecutor => {
-  const over = (runner: Pick<PGlite, "query">): SqlConnection => ({
-    execute: async ({ sql, params }) => {
-      const result = await runner.query<Record<string, unknown>>(sql, [
-        ...params,
-      ]);
-      return { rows: result.rows, changes: result.affectedRows ?? 0 };
-    },
-  });
-  return {
-    dialect: "postgresql",
-    ...over(db),
-    transaction: (fn) => db.transaction((tx) => fn(over(tx))),
-  };
-};
-
-/** One connection, so statements and transactions run one at a time. */
-export const sqliteExecutor = (db: DatabaseSync): SqlExecutor => {
-  let queue: Promise<unknown> = Promise.resolve();
-  const serial = <T>(task: () => Promise<T>): Promise<T> => {
-    const next = queue.then(task);
-    queue = next.catch(() => undefined);
-    return next;
-  };
-  const execute = async ({ sql, params }: SqlStatement): Promise<SqlResult> => {
-    const statement = db.prepare(sql);
-    const values = params as SqliteValue[];
-    if (statement.columns().length > 0) {
-      return { rows: statement.all(...values), changes: 0 };
-    }
-    return { rows: [], changes: Number(statement.run(...values).changes) };
-  };
-  return {
-    dialect: "sqlite",
-    execute: (statement) => serial(() => execute(statement)),
-    transaction: (fn) =>
-      serial(async () => {
-        db.exec("BEGIN IMMEDIATE");
-        try {
-          const result = await fn({ execute });
-          db.exec("COMMIT");
-          return result;
-        } catch (error) {
-          db.exec("ROLLBACK");
-          throw error;
-        }
-      }),
-  };
-};
-
-/**
- * An executor without interactive transactions, as D1's: writes run as one
- * atomic batch, here in a SQLite transaction that rolls back on any error.
- */
-export const sqliteBatchExecutor = (db: DatabaseSync): SqlExecutor => {
-  const executor = sqliteExecutor(db);
-  return {
-    dialect: "sqlite",
-    execute: executor.execute,
-    transaction: () => {
-      throw new Error("A batch executor has no interactive transactions.");
-    },
-    batch: (statements) =>
-      executor.transaction(async (connection) => {
-        const results: SqlResult[] = [];
-        for (const statement of statements) {
-          results.push(await connection.execute(statement));
-        }
-        return results;
-      }),
-  };
-};
-
-/** PGlite without interactive transactions, as an RPC applying a batch would be. */
-export const pgliteBatchExecutor = (db: PGlite): SqlExecutor => {
-  const executor = pgliteExecutor(db);
-  return {
-    dialect: "postgresql",
-    execute: executor.execute,
-    transaction: () => {
-      throw new Error("A batch executor has no interactive transactions.");
-    },
-    batch: (statements) =>
-      executor.transaction(async (connection) => {
-        const results: SqlResult[] = [];
-        for (const statement of statements) {
-          results.push(await connection.execute(statement));
-        }
-        return results;
-      }),
-  };
-};
-
-export const pgExecutor = (pool: PgPool): SqlExecutor => {
-  const over = (runner: PgPool | PoolClient): SqlConnection => ({
-    execute: async ({ sql, params }) => {
-      const result = await runner.query(sql, [...params]);
-      return { rows: result.rows, changes: result.rowCount ?? 0 };
-    },
-  });
-  return {
-    dialect: "postgresql",
-    ...over(pool),
-    async transaction(fn) {
-      const client = await pool.connect();
-      try {
-        await client.query("BEGIN");
-        const result = await fn(over(client));
-        await client.query("COMMIT");
-        return result;
-      } catch (error) {
-        await client.query("ROLLBACK").catch(() => undefined);
-        throw error;
-      } finally {
-        client.release();
-      }
-    },
-  };
-};
-
-/** A pooled PostgreSQL batch: one READ COMMITTED transaction per write, as Supabase's apply RPC runs. */
-export const pgBatchExecutor = (pool: PgPool): SqlExecutor => {
-  const executor = pgExecutor(pool);
-  return {
-    dialect: "postgresql",
-    execute: executor.execute,
-    transaction: () => {
-      throw new Error("A batch executor has no interactive transactions.");
-    },
-    batch: (statements) =>
-      executor.transaction(async (connection) => {
-        const results: SqlResult[] = [];
-        for (const statement of statements) {
-          results.push(await connection.execute(statement));
-        }
-        return results;
-      }),
-  };
-};
-
-export const mysqlExecutor = (pool: MysqlPool): SqlExecutor => {
-  const over = (runner: MysqlPool | PoolConnection): SqlConnection => ({
-    execute: async ({ sql, params }) => {
-      const [result] = await runner.query(sql, [...params]);
-      return Array.isArray(result)
-        ? { rows: result as Record<string, unknown>[], changes: 0 }
-        : { rows: [], changes: result.affectedRows };
-    },
-  });
-  return {
-    dialect: "mysql",
-    ...over(pool),
-    async transaction(fn) {
-      const connection = await pool.getConnection();
-      try {
-        await connection.beginTransaction();
-        const result = await fn(over(connection));
-        await connection.commit();
-        return result;
-      } catch (error) {
-        await connection.rollback().catch(() => undefined);
-        throw error;
-      } finally {
-        connection.release();
-      }
-    },
-  };
-};

package/src/databaseTestSuite.spec.ts

@@ -1,44 +0,0 @@
-import { createMemoryAdapter } from "@hot-updater/plugin-core/internal";
-import {
-  setupDatabaseTestSuite,
-  startHttpTestServer,
-} from "@hot-updater/test-utils";
-
-import { createDatabasePluginApis } from "./assembly/databasePlugins";
-import { createHotUpdater } from "./index";
-import { createInsightsModel, insights } from "./plugins/insights";
-import { insightsTestSuite } from "./plugins/insights/testing";
-
-let adapter = createMemoryAdapter();
-
-setupDatabaseTestSuite({
-  name: "in-memory engine database",
-  migrate: () => undefined,
-  createDatabase: () => ({
-    name: "memory",
-    // Each test's reset swaps in an empty adapter.
-    adapter: new Proxy({} as typeof adapter, {
-      get: (_target, key) => Reflect.get(adapter, key),
-    }),
-  }),
-  reset: () => {
-    adapter = createMemoryAdapter();
-  },
-  dispose: () => undefined,
-  createHttpClient: (options) =>
-    startHttpTestServer(
-      createHotUpdater({
-        ...options,
-        plugins: [insights()],
-        clientAccess: "public",
-      }).handlers,
-    ),
-  plugins: [
-    insightsTestSuite({
-      createModel: (database) =>
-        createInsightsModel(
-          createDatabasePluginApis(database, [insights()]).insights,
-        ),
-    }),
-  ],
-});

package/src/db/bundleRows.spec.ts

@@ -1,164 +0,0 @@
-import type { Bundle } from "@hot-updater/core";
-import { describe, expect, it } from "vitest";
-
-import {
-  BundleRowHydrationError,
-  bundleToPatchRows,
-  bundleToRow,
-  rowsToBundles,
-  type BundlePatchRow,
-  type BundleRow,
-} from "./bundleRows";
-
-const createBundle = (id: string): Bundle => ({
-  id,
-  platform: "ios",
-  gitCommitHash: null,
-  manifestStorageUri: `s3://bucket/${id}/manifest.json`,
-  manifestFileHash: `manifest-hash-${id}`,
-  assetBaseStorageUri: "s3://bucket/assets",
-});
-
-const toRow = (bundle: Bundle): BundleRow => bundleToRow(bundle);
-
-const createPatchRow = (
-  id: string,
-  bundleId: string,
-  baseBundleId: string,
-  orderIndex: number,
-): BundlePatchRow => ({
-  id,
-  bundle_id: bundleId,
-  base_bundle_id: baseBundleId,
-  base_file_hash: `base-hash-${id}`,
-  patch_file_hash: `patch-hash-${id}`,
-  patch_storage_uri: `s3://bucket/${id}.patch`,
-  byte_size: 3_000_000_002,
-  order_index: orderIndex,
-});
-
-describe("bundle row conversion", () => {
-  it("round-trips bundle fields without embedding patch artifacts in the bundle row", () => {
-    const baseBundle = createBundle("base");
-    const bundle: Bundle = {
-      ...createBundle("target"),
-      metadata: { app_version: "1.0.0" },
-      manifestStorageUri: "s3://bucket/manifest.json",
-      manifestFileHash: "manifest-hash",
-      assetBaseStorageUri: "s3://bucket/assets",
-      patches: [
-        {
-          baseBundleId: baseBundle.id,
-          baseFileHash: "base-hash",
-          byteSize: 3_000_000_002,
-          patchFileHash: "patch-hash",
-          patchStorageUri: "s3://bucket/target.patch",
-        },
-      ],
-    };
-
-    const row = toRow(bundle);
-    const patchRows = bundleToPatchRows(bundle);
-    const hydratedBundles = rowsToBundles([row], patchRows, [
-      toRow(baseBundle),
-    ]);
-
-    expect(row).not.toHaveProperty("patches");
-    expect(row).not.toHaveProperty("patch_file_hash");
-    expect(row).not.toHaveProperty("channel");
-    expect(row).not.toHaveProperty("enabled");
-    expect(hydratedBundles).toHaveLength(1);
-    expect(hydratedBundles[0]).toEqual(bundle);
-  });
-
-  it("orders multiple patches deterministically", () => {
-    const oldest = createBundle("oldest");
-    const newest = createBundle("newest");
-    const target = createBundle("target");
-    const rows: readonly BundleRow[] = [toRow(target)];
-    const later = createPatchRow("later", target.id, newest.id, 1);
-    const firstById = createPatchRow("a-first", target.id, oldest.id, 0);
-    const secondById = createPatchRow("z-second", target.id, newest.id, 0);
-
-    const [hydrated] = rowsToBundles(
-      rows,
-      [later, secondById, firstById],
-      [toRow(oldest), toRow(newest)],
-    );
-
-    expect(hydrated?.patches?.map((patch) => patch.patchFileHash)).toEqual([
-      firstById.patch_file_hash,
-      secondById.patch_file_hash,
-      later.patch_file_hash,
-    ]);
-  });
-
-  it("hydrates an empty patch set", () => {
-    const bundle = createBundle("without-patches");
-
-    const [hydrated] = rowsToBundles([toRow(bundle)], [], []);
-
-    expect(hydrated).toMatchObject({ patches: [] });
-  });
-
-  it("preserves nested metadata at the row boundary", () => {
-    const row: BundleRow = {
-      ...toRow(createBundle("nested-metadata")),
-      metadata: { release: { flags: [true, null, 3] } },
-    };
-
-    const [hydrated] = rowsToBundles([row], [], []);
-
-    expect(hydrated).toMatchObject({
-      metadata: { release: { flags: [true, null, 3] } },
-    });
-  });
-
-  it("rejects duplicate patch ids during aggregate hydration", () => {
-    const base = createBundle("base");
-    const target = createBundle("target");
-    const patch = createPatchRow("duplicate", target.id, base.id, 0);
-    const duplicate = { ...patch, base_file_hash: "different-hash" };
-
-    const hydrate = () =>
-      rowsToBundles([toRow(target)], [patch, duplicate], [toRow(base)]);
-
-    expect(hydrate).toThrowError(BundleRowHydrationError);
-    expect(hydrate).toThrowError(
-      expect.objectContaining({
-        reason: "duplicate_patch_id",
-        patchId: patch.id,
-      }),
-    );
-  });
-
-  it("rejects a patch whose owner bundle row is absent", () => {
-    const base = createBundle("base");
-    const patch = createPatchRow("orphan-owner", "missing", base.id, 0);
-
-    const hydrate = () => rowsToBundles([], [patch], [toRow(base)]);
-
-    expect(hydrate).toThrowError(
-      expect.objectContaining({
-        reason: "orphan_patch_owner",
-        patchId: patch.id,
-        bundleId: patch.bundle_id,
-      }),
-    );
-  });
-
-  it("rejects a patch whose base bundle row is absent", () => {
-    const target = createBundle("target");
-    const patch = createPatchRow("orphan-base", target.id, "missing", 0);
-
-    const hydrate = () => rowsToBundles([toRow(target)], [patch], []);
-
-    expect(hydrate).toThrowError(
-      expect.objectContaining({
-        reason: "orphan_patch_base",
-        patchId: patch.id,
-        bundleId: patch.base_bundle_id,
-      }),
-    );
-  });
-});

package/src/db/bundleRows.ts

@@ -1,10 +0,0 @@
-export {
-  BundleRowHydrationError,
-  BundleRowHydrationErrorReason,
-  bundleToPatchRows,
-  bundleToRow,
-  rowToBundle,
-  rowsToBundles,
-} from "@hot-updater/plugin-core";
-
-export type { BundlePatchRow, BundleRow } from "@hot-updater/plugin-core";