@better-forge/backup 0.1.0 → 0.1.1

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 BetterStatusPage contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 BetterStatusPage contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,12 +1,12 @@
-# @better-forge/backup
-
-Backup, restore and verification of a SQLite database and the files around it.
-
-- `createBackupService` writes a consistent snapshot of the database (`VACUUM INTO`, integrity-checked) plus the files the application adds, into one checksummed archive, and verifies, lists, prunes and locks backups. The schedule and the last status are kept as files beside the backups.
-- `createRestore` restores an archive over a stopped application, takes a safety backup first and puts every replaced file back if the restore fails half way. The application supplies the files around the database, its database handle and the checks that may refuse a backup.
-- `createBackupRunner` and `@better-forge/backup/worker` run a backup or a verification on a worker thread.
-- `createBackupRoutes` makes the admin routes (list, create, schedule, download, delete, verify an uploaded file) and `createBackupScheduler` runs backups on the configured schedule.
-- `runBackupCli` and `runRestoreCli` are the command lines of `backup`, `backup --verify` and `restore`; the application keeps its boot (environment, database) in the entry file.
-- `createArchiveFormat` is the archive format on its own; the `magic` bytes identify the archives of one product.
-
-Depends on `@better-forge/audit` (the routes) and `node-cron` (the scheduler); the service itself needs only Node (`node:sqlite`).
+# @better-forge/backup
+
+Backup, restore and verification of a SQLite database and the files around it.
+
+- `createBackupService` writes a consistent snapshot of the database (`VACUUM INTO`, integrity-checked) plus the files the application adds, into one checksummed archive, and verifies, lists, prunes and locks backups. The schedule and the last status are kept as files beside the backups.
+- `createRestore` restores an archive over a stopped application, takes a safety backup first and puts every replaced file back if the restore fails half way. The application supplies the files around the database, its database handle and the checks that may refuse a backup.
+- `createBackupRunner` and `@better-forge/backup/worker` run a backup or a verification on a worker thread.
+- `createBackupRoutes` makes the admin routes (list, create, schedule, download, delete, verify an uploaded file) and `createBackupScheduler` runs backups on the configured schedule.
+- `runBackupCli` and `runRestoreCli` are the command lines of `backup`, `backup --verify` and `restore`; the application keeps its boot (environment, database) in the entry file.
+- `createArchiveFormat` is the archive format on its own; the `magic` bytes identify the archives of one product.
+
+Depends on `@better-forge/audit` (the routes) and `node-cron` (the scheduler); the service itself needs only Node (`node:sqlite`).

package/package.json

@@ -1,57 +1,57 @@
-{
-  "name": "@better-forge/backup",
-  "version": "0.1.0",
-  "description": "Backup, restore, verification, scheduler and CLI.",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/BElluu/Better-Forge.git",
-    "directory": "packages/backup"
-  },
-  "homepage": "https://github.com/BElluu/Better-Forge/tree/main/packages/backup#readme",
-  "bugs": {
-    "url": "https://github.com/BElluu/Better-Forge/issues"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    },
-    "./worker": {
-      "types": "./dist/worker.d.ts",
-      "import": "./dist/worker.js"
-    },
-    "./package.json": "./package.json"
-  },
-  "files": [
-    "dist",
-    "src",
-    "!src/**/*.test.*"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput"
-  },
-  "peerDependencies": {
-    "fastify": "^5.3.2"
-  },
-  "devDependencies": {
-    "@types/node": "^26.6.2",
-    "fastify": "^5.3.2",
-    "typescript": "^5.7.3"
-  },
-  "dependencies": {
-    "node-cron": "^4.6.0",
-    "@better-forge/audit": "0.1.0",
-    "@better-forge/db": "0.1.0"
-  },
-  "engines": {
-    "node": ">=26.10.0"
-  }
-}
+{
+  "name": "@better-forge/backup",
+  "version": "0.1.1",
+  "description": "Backup, restore, verification, scheduler and CLI.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BElluu/Better-Forge.git",
+    "directory": "packages/backup"
+  },
+  "homepage": "https://github.com/BElluu/Better-Forge/tree/main/packages/backup#readme",
+  "bugs": {
+    "url": "https://github.com/BElluu/Better-Forge/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./worker": {
+      "types": "./dist/worker.d.ts",
+      "import": "./dist/worker.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.*"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput"
+  },
+  "peerDependencies": {
+    "fastify": "^5.3.2"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.2",
+    "fastify": "^5.3.2",
+    "typescript": "^5.7.3"
+  },
+  "dependencies": {
+    "node-cron": "^4.6.0",
+    "@better-forge/audit": "0.1.1",
+    "@better-forge/db": "0.1.1"
+  },
+  "engines": {
+    "node": ">=26.10.0"
+  }
+}

package/src/archive.ts

@@ -1,114 +1,114 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import crypto from 'node:crypto'
-
-const HASH_SIZE = 32
-
-export interface ArchiveEntry { name: string; source: string }
-
-function safeName(name: string): string {
-  const normalized = name.replaceAll('\\', '/')
-  if (!normalized || normalized.startsWith('/') || normalized.includes('../') || normalized === '..') {
-    throw new Error(`Unsafe archive path: ${name}`)
-  }
-  return normalized
-}
-
-function sha256(file: string): Buffer {
-  const hash = crypto.createHash('sha256')
-  const fd = fs.openSync(file, 'r')
-  const buffer = Buffer.allocUnsafe(1024 * 1024)
-  try {
-    let count = 0
-    while ((count = fs.readSync(fd, buffer, 0, buffer.length, null)) > 0) hash.update(buffer.subarray(0, count))
-  } finally { fs.closeSync(fd) }
-  return hash.digest()
-}
-
-function copyBytes(input: number, output: number, size: number, hash?: crypto.Hash): void {
-  const buffer = Buffer.allocUnsafe(1024 * 1024)
-  let remaining = size
-  while (remaining > 0) {
-    const count = fs.readSync(input, buffer, 0, Math.min(buffer.length, remaining), null)
-    if (count === 0) throw new Error('Unexpected end of backup archive')
-    const chunk = buffer.subarray(0, count)
-    if (hash) hash.update(chunk)
-    fs.writeSync(output, chunk)
-    remaining -= count
-  }
-}
-
-function readExact(fd: number, size: number): Buffer {
-  const buffer = Buffer.alloc(size)
-  let offset = 0
-  while (offset < size) {
-    const count = fs.readSync(fd, buffer, offset, size - offset, null)
-    if (!count) throw new Error('Truncated backup archive')
-    offset += count
-  }
-  return buffer
-}
-
-/**
- * The archive file format: a magic header, then for each file its name, size and SHA-256 followed by its bytes.
- * Extraction checks every checksum and refuses names that would leave the destination. The `magic` is what identifies
- * archives of one product, so an application keeps the one its existing archives start with.
- */
-export function createArchiveFormat(options: { magic: string }) {
-  const MAGIC = Buffer.from(options.magic)
-
-  function createArchive(output: string, entries: ArchiveEntry[]): void {
-    const fd = fs.openSync(output, 'wx', 0o600)
-    try {
-      fs.writeSync(fd, MAGIC)
-      for (const entry of entries) {
-        const name = Buffer.from(safeName(entry.name), 'utf8')
-        const stat = fs.statSync(entry.source)
-        if (!stat.isFile()) throw new Error(`Archive source is not a file: ${entry.source}`)
-        const header = Buffer.alloc(4 + 8 + HASH_SIZE)
-        header.writeUInt32BE(name.length, 0)
-        header.writeBigUInt64BE(BigInt(stat.size), 4)
-        sha256(entry.source).copy(header, 12)
-        fs.writeSync(fd, header)
-        fs.writeSync(fd, name)
-        const input = fs.openSync(entry.source, 'r')
-        try { copyBytes(input, fd, stat.size) } finally { fs.closeSync(input) }
-      }
-      fs.writeSync(fd, Buffer.alloc(4))
-      fs.fsyncSync(fd)
-    } finally { fs.closeSync(fd) }
-  }
-
-  function extractArchive(input: string, destination: string): string[] {
-    fs.mkdirSync(destination, { recursive: true, mode: 0o700 })
-    const root = path.resolve(destination)
-    const extracted: string[] = []
-    const fd = fs.openSync(input, 'r')
-    try {
-      if (!readExact(fd, MAGIC.length).equals(MAGIC)) throw new Error('Unsupported backup format')
-      for (let index = 0; index < 10000; index++) {
-        const nameLength = readExact(fd, 4).readUInt32BE(0)
-        if (nameLength === 0) return extracted
-        if (nameLength > 4096) throw new Error('Invalid archive entry name')
-        const metadata = readExact(fd, 8 + HASH_SIZE)
-        const sizeBig = metadata.readBigUInt64BE(0)
-        if (sizeBig > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error('Archive entry is too large')
-        const expectedHash = metadata.subarray(8)
-        const name = safeName(readExact(fd, nameLength).toString('utf8'))
-        const target = path.resolve(root, ...name.split('/'))
-        if (target !== root && !target.startsWith(`${root}${path.sep}`)) throw new Error('Archive path escapes destination')
-        fs.mkdirSync(path.dirname(target), { recursive: true })
-        const output = fs.openSync(target, 'wx', 0o600)
-        const hash = crypto.createHash('sha256')
-        try { copyBytes(fd, output, Number(sizeBig), hash) } finally { fs.closeSync(output) }
-        if (!crypto.timingSafeEqual(hash.digest(), expectedHash)) throw new Error(`Checksum mismatch: ${name}`)
-        extracted.push(name)
-      }
-      throw new Error('Archive contains too many entries')
-    } finally { fs.closeSync(fd) }
-  }
-
-  return { createArchive, extractArchive }
-}
-
-export type ArchiveFormat = ReturnType<typeof createArchiveFormat>
+import fs from 'node:fs'
+import path from 'node:path'
+import crypto from 'node:crypto'
+
+const HASH_SIZE = 32
+
+export interface ArchiveEntry { name: string; source: string }
+
+function safeName(name: string): string {
+  const normalized = name.replaceAll('\\', '/')
+  if (!normalized || normalized.startsWith('/') || normalized.includes('../') || normalized === '..') {
+    throw new Error(`Unsafe archive path: ${name}`)
+  }
+  return normalized
+}
+
+function sha256(file: string): Buffer {
+  const hash = crypto.createHash('sha256')
+  const fd = fs.openSync(file, 'r')
+  const buffer = Buffer.allocUnsafe(1024 * 1024)
+  try {
+    let count = 0
+    while ((count = fs.readSync(fd, buffer, 0, buffer.length, null)) > 0) hash.update(buffer.subarray(0, count))
+  } finally { fs.closeSync(fd) }
+  return hash.digest()
+}
+
+function copyBytes(input: number, output: number, size: number, hash?: crypto.Hash): void {
+  const buffer = Buffer.allocUnsafe(1024 * 1024)
+  let remaining = size
+  while (remaining > 0) {
+    const count = fs.readSync(input, buffer, 0, Math.min(buffer.length, remaining), null)
+    if (count === 0) throw new Error('Unexpected end of backup archive')
+    const chunk = buffer.subarray(0, count)
+    if (hash) hash.update(chunk)
+    fs.writeSync(output, chunk)
+    remaining -= count
+  }
+}
+
+function readExact(fd: number, size: number): Buffer {
+  const buffer = Buffer.alloc(size)
+  let offset = 0
+  while (offset < size) {
+    const count = fs.readSync(fd, buffer, offset, size - offset, null)
+    if (!count) throw new Error('Truncated backup archive')
+    offset += count
+  }
+  return buffer
+}
+
+/**
+ * The archive file format: a magic header, then for each file its name, size and SHA-256 followed by its bytes.
+ * Extraction checks every checksum and refuses names that would leave the destination. The `magic` is what identifies
+ * archives of one product, so an application keeps the one its existing archives start with.
+ */
+export function createArchiveFormat(options: { magic: string }) {
+  const MAGIC = Buffer.from(options.magic)
+
+  function createArchive(output: string, entries: ArchiveEntry[]): void {
+    const fd = fs.openSync(output, 'wx', 0o600)
+    try {
+      fs.writeSync(fd, MAGIC)
+      for (const entry of entries) {
+        const name = Buffer.from(safeName(entry.name), 'utf8')
+        const stat = fs.statSync(entry.source)
+        if (!stat.isFile()) throw new Error(`Archive source is not a file: ${entry.source}`)
+        const header = Buffer.alloc(4 + 8 + HASH_SIZE)
+        header.writeUInt32BE(name.length, 0)
+        header.writeBigUInt64BE(BigInt(stat.size), 4)
+        sha256(entry.source).copy(header, 12)
+        fs.writeSync(fd, header)
+        fs.writeSync(fd, name)
+        const input = fs.openSync(entry.source, 'r')
+        try { copyBytes(input, fd, stat.size) } finally { fs.closeSync(input) }
+      }
+      fs.writeSync(fd, Buffer.alloc(4))
+      fs.fsyncSync(fd)
+    } finally { fs.closeSync(fd) }
+  }
+
+  function extractArchive(input: string, destination: string): string[] {
+    fs.mkdirSync(destination, { recursive: true, mode: 0o700 })
+    const root = path.resolve(destination)
+    const extracted: string[] = []
+    const fd = fs.openSync(input, 'r')
+    try {
+      if (!readExact(fd, MAGIC.length).equals(MAGIC)) throw new Error('Unsupported backup format')
+      for (let index = 0; index < 10000; index++) {
+        const nameLength = readExact(fd, 4).readUInt32BE(0)
+        if (nameLength === 0) return extracted
+        if (nameLength > 4096) throw new Error('Invalid archive entry name')
+        const metadata = readExact(fd, 8 + HASH_SIZE)
+        const sizeBig = metadata.readBigUInt64BE(0)
+        if (sizeBig > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error('Archive entry is too large')
+        const expectedHash = metadata.subarray(8)
+        const name = safeName(readExact(fd, nameLength).toString('utf8'))
+        const target = path.resolve(root, ...name.split('/'))
+        if (target !== root && !target.startsWith(`${root}${path.sep}`)) throw new Error('Archive path escapes destination')
+        fs.mkdirSync(path.dirname(target), { recursive: true })
+        const output = fs.openSync(target, 'wx', 0o600)
+        const hash = crypto.createHash('sha256')
+        try { copyBytes(fd, output, Number(sizeBig), hash) } finally { fs.closeSync(output) }
+        if (!crypto.timingSafeEqual(hash.digest(), expectedHash)) throw new Error(`Checksum mismatch: ${name}`)
+        extracted.push(name)
+      }
+      throw new Error('Archive contains too many entries')
+    } finally { fs.closeSync(fd) }
+  }
+
+  return { createArchive, extractArchive }
+}
+
+export type ArchiveFormat = ReturnType<typeof createArchiveFormat>

package/src/cli.ts

@@ -1,62 +1,62 @@
-import path from 'node:path'
-import type { BackupService } from './service.js'
-
-function argument(argv: string[], name: string): string | undefined {
-  const index = argv.indexOf(name)
-  return index >= 0 ? argv[index + 1] : undefined
-}
-
-function fail(error: unknown): void {
-  console.error(error instanceof Error ? error.message : error)
-  process.exitCode = 1
-}
-
-export interface BackupCliOptions {
-  service: Pick<BackupService, 'createBackup' | 'validateBackup'>
-  /** The application's database handle: opened for the backup and closed after it. */
-  database: { open: () => void; close: () => void }
-  /** A backup file name as the usage line shows it (`<name>-backup-timestamp.backup`). */
-  exampleFile: string
-}
-
-/**
- * The command line of `backup`: makes a backup (`--output <dir>` picks where) or, with `--verify <file>` /
- * `--verify --input <file>`, checks one. Prints JSON; failures set a non-zero exit code.
- */
-export async function runBackupCli(argv: string[], options: BackupCliOptions): Promise<void> {
-  try {
-    const verifyMode = argv.includes('--verify')
-    const verify = argument(argv, '--input') ?? argument(argv, '--verify')
-    if (verifyMode) {
-      if (!verify || verify.startsWith('--')) throw new Error(`Usage: backup:verify -- --input <${options.exampleFile}>`)
-      const manifest = options.service.validateBackup(path.resolve(verify))
-      console.log(JSON.stringify({ valid: true, manifest }, null, 2))
-      return
-    }
-    options.database.open()
-    try {
-      const output = argument(argv, '--output')
-      console.log(JSON.stringify(await options.service.createBackup(output ? path.resolve(output) : undefined), null, 2))
-    } finally { options.database.close() }
-  } catch (error) { fail(error) }
-}
-
-export interface RestoreCliOptions {
-  restore: (input: string, extra: string) => Promise<unknown>
-  exampleFile: string
-  /** The one extra value the restore needs (for example the key the backup was made with). */
-  extra: { flag: string; placeholder: string }
-}
-
-/** The command line of `restore`: `--input <file>` and the extra flag are both required. */
-export async function runRestoreCli(argv: string[], options: RestoreCliOptions): Promise<void> {
-  const input = argument(argv, '--input')
-  const extra = argument(argv, options.extra.flag)
-  if (!input || !extra) {
-    console.error(`Usage: restore --input <${options.exampleFile}> ${options.extra.flag} ${options.extra.placeholder}`)
-    process.exitCode = 1
-    return
-  }
-  try { console.log(JSON.stringify(await options.restore(path.resolve(input), extra), null, 2)) }
-  catch (error) { fail(error) }
-}
+import path from 'node:path'
+import type { BackupService } from './service.js'
+
+function argument(argv: string[], name: string): string | undefined {
+  const index = argv.indexOf(name)
+  return index >= 0 ? argv[index + 1] : undefined
+}
+
+function fail(error: unknown): void {
+  console.error(error instanceof Error ? error.message : error)
+  process.exitCode = 1
+}
+
+export interface BackupCliOptions {
+  service: Pick<BackupService, 'createBackup' | 'validateBackup'>
+  /** The application's database handle: opened for the backup and closed after it. */
+  database: { open: () => void; close: () => void }
+  /** A backup file name as the usage line shows it (`<name>-backup-timestamp.backup`). */
+  exampleFile: string
+}
+
+/**
+ * The command line of `backup`: makes a backup (`--output <dir>` picks where) or, with `--verify <file>` /
+ * `--verify --input <file>`, checks one. Prints JSON; failures set a non-zero exit code.
+ */
+export async function runBackupCli(argv: string[], options: BackupCliOptions): Promise<void> {
+  try {
+    const verifyMode = argv.includes('--verify')
+    const verify = argument(argv, '--input') ?? argument(argv, '--verify')
+    if (verifyMode) {
+      if (!verify || verify.startsWith('--')) throw new Error(`Usage: backup:verify -- --input <${options.exampleFile}>`)
+      const manifest = options.service.validateBackup(path.resolve(verify))
+      console.log(JSON.stringify({ valid: true, manifest }, null, 2))
+      return
+    }
+    options.database.open()
+    try {
+      const output = argument(argv, '--output')
+      console.log(JSON.stringify(await options.service.createBackup(output ? path.resolve(output) : undefined), null, 2))
+    } finally { options.database.close() }
+  } catch (error) { fail(error) }
+}
+
+export interface RestoreCliOptions {
+  restore: (input: string, extra: string) => Promise<unknown>
+  exampleFile: string
+  /** The one extra value the restore needs (for example the key the backup was made with). */
+  extra: { flag: string; placeholder: string }
+}
+
+/** The command line of `restore`: `--input <file>` and the extra flag are both required. */
+export async function runRestoreCli(argv: string[], options: RestoreCliOptions): Promise<void> {
+  const input = argument(argv, '--input')
+  const extra = argument(argv, options.extra.flag)
+  if (!input || !extra) {
+    console.error(`Usage: restore --input <${options.exampleFile}> ${options.extra.flag} ${options.extra.placeholder}`)
+    process.exitCode = 1
+    return
+  }
+  try { console.log(JSON.stringify(await options.restore(path.resolve(input), extra), null, 2)) }
+  catch (error) { fail(error) }
+}

package/src/index.ts

@@ -1,10 +1,10 @@
-export { createArchiveFormat, type ArchiveEntry, type ArchiveFormat } from './archive.js'
-export {
-  collectFiles, createBackupService, DEFAULT_BACKUP_CONFIG, DEFAULT_BACKUP_STATUS, INTERRUPTED_BACKUP_ERROR,
-  type BackupConfig, type BackupInfo, type BackupManifest, type BackupService, type BackupServiceOptions, type BackupStatus, type ProcessOwner,
-} from './service.js'
-export { createRestore, replaceFile, type RestoreExtras, type RestoreOptions, type RestoreResult } from './restore.js'
-export { createBackupRunner, spawnBackupWorker, type BackupJob, type BackupWorkerOptions } from './runner.js'
-export { createBackupScheduler, scheduleExpression, type BackupSchedulerOptions } from './scheduler.js'
-export { createBackupRoutes, type BackupRoutesOptions } from './routes.js'
-export { runBackupCli, runRestoreCli, type BackupCliOptions, type RestoreCliOptions } from './cli.js'
+export { createArchiveFormat, type ArchiveEntry, type ArchiveFormat } from './archive.js'
+export {
+  collectFiles, createBackupService, DEFAULT_BACKUP_CONFIG, DEFAULT_BACKUP_STATUS, INTERRUPTED_BACKUP_ERROR,
+  type BackupConfig, type BackupInfo, type BackupManifest, type BackupService, type BackupServiceOptions, type BackupStatus, type ProcessOwner,
+} from './service.js'
+export { createRestore, replaceFile, type RestoreExtras, type RestoreOptions, type RestoreResult } from './restore.js'
+export { createBackupRunner, spawnBackupWorker, type BackupJob, type BackupWorkerOptions } from './runner.js'
+export { createBackupScheduler, scheduleExpression, type BackupSchedulerOptions } from './scheduler.js'
+export { createBackupRoutes, type BackupRoutesOptions } from './routes.js'
+export { runBackupCli, runRestoreCli, type BackupCliOptions, type RestoreCliOptions } from './cli.js'