@context-use/open-sync 0.1.0

package/src/repositories/acquisition/sqlite.ts

@@ -0,0 +1,60 @@
+import type { Database } from 'bun:sqlite';
+import { definitionKey, type SyncDefinition, type SyncPage } from '../../models/definition';
+import type { DeliveredRecord } from '../../models/delivery';
+import { fail } from '../../models/error';
+import { canonicalJson } from '../../models/json';
+import type { QueueLimits } from '../../models/limits';
+import { preparePage } from '../../models/page';
+import { hasQueueCapacity } from '../queue-usage';
+import type { AcquisitionRepository, RunLease } from './contract';
+import { assertRun, claimRun, finishRun } from './lease';
+import { enqueue } from './outbox';
+import { writeRecord } from './records';
+
+export class SqliteAcquisition implements AcquisitionRepository {
+  constructor(
+    private readonly input: { db: Database; limits: QueueLimits; historyLimit: number },
+  ) {}
+  claim(leaseMs: number) {
+    return claimRun({ ...this.input, leaseMs });
+  }
+  hasCapacity() {
+    return hasQueueCapacity(this.input);
+  }
+  commit(input: { lease: RunLease; page: SyncPage; definition: SyncDefinition }): void {
+    const { db, limits } = this.input;
+    const page = preparePage({ ...input, limits });
+    db.transaction(() => {
+      const installation = assertRun({ db, lease: input.lease });
+      if (definitionKey(input.definition) !== definitionKey(installation.definition)) {
+        fail('definition_conflict');
+      }
+      const records: DeliveredRecord[] = [];
+      for (const record of page.deliverable.records) {
+        const changed = writeRecord({ db, installation, record });
+        if (changed) {
+          records.push(changed);
+        }
+      }
+      enqueue({ db, installation, records, limits });
+      db.query(
+        'UPDATE installations SET checkpoint=?,checkpoint_revision=checkpoint_revision+1 WHERE owner_id=? AND id=?',
+      ).run(canonicalJson(page.checkpoint).json, installation.ownerId, installation.id);
+      db.query(
+        'UPDATE runs SET checkpoint_revision=checkpoint_revision+1,pages=pages+1 WHERE owner_id=? AND id=?',
+      ).run(input.lease.ownerId, input.lease.id);
+      if (page.complete) {
+        finishRun({ db, lease: input.lease, state: 'succeeded', delay: installation.intervalMs });
+      }
+    }).immediate();
+    input.lease.checkpointRevision++;
+  }
+  finish(input: { lease: RunLease; state: string; delay: number }): void {
+    this.input.db
+      .transaction(() => {
+        assertRun({ db: this.input.db, lease: input.lease });
+        finishRun({ db: this.input.db, ...input });
+      })
+      .immediate();
+  }
+}

package/src/repositories/catalog/contract.ts

@@ -0,0 +1,23 @@
+import type { SyncDefinition } from '../../models/definition';
+import type { Destination } from '../../models/delivery';
+import type { Resource, Scope } from '../../models/identity';
+import type { CreateInstallation, Installation, SyncRun } from '../../models/installation';
+import type { JsonObject, JsonValue } from '../../models/json';
+
+export interface CatalogRepository {
+  register(definition: SyncDefinition): void;
+  createDestination(
+    input: Scope & { type: string; version: string; config: JsonObject },
+  ): Destination;
+  destinations(scope: Scope): Destination[];
+  createInstallation(input: CreateInstallation & { initialCheckpoint: JsonValue }): Installation;
+  installation(input: Resource): Installation;
+  installations(scope: Scope): Installation[];
+  runs(input: Resource & { offset: number }): {
+    runs: SyncRun[];
+    hasMore: boolean;
+    pageSize: number;
+  };
+  setEnabled(input: Resource & { enabled: boolean }): Installation;
+  queue(input: Resource & { checkpoint?: JsonValue }): void;
+}

package/src/repositories/catalog/sqlite.ts

@@ -0,0 +1,166 @@
+import type { Database } from 'bun:sqlite';
+import type { SyncDefinition } from '../../models/definition';
+import { fail } from '../../models/error';
+import type { Resource, Scope } from '../../models/identity';
+import type { CreateInstallation } from '../../models/installation';
+import { canonicalJson, type JsonObject, type JsonValue } from '../../models/json';
+import { defaultTiming } from '../../models/limits';
+import { readDestination, readInstallation } from '../rows';
+import type { CatalogRepository } from './contract';
+
+export class SqliteCatalog implements CatalogRepository {
+  constructor(private readonly db: Database) {}
+  register(definition: SyncDefinition): void {
+    const manifest = canonicalJson(definition).json;
+    this.db
+      .transaction(() => {
+        const previous = this.db
+          .query<{ manifest: string }, [string, string]>(
+            'SELECT manifest FROM definitions WHERE id=? AND version=?',
+          )
+          .get(definition.id, definition.version);
+        if (previous && previous.manifest !== manifest) {
+          fail('definition_conflict');
+        }
+        this.db
+          .query('INSERT OR IGNORE INTO definitions VALUES (?,?,?,?)')
+          .run(definition.id, definition.version, definition.artifactId, manifest);
+      })
+      .immediate();
+  }
+  createDestination(input: Scope & { type: string; version: string; config: JsonObject }) {
+    const id = `dest_${crypto.randomUUID()}`;
+    this.db
+      .query('INSERT INTO destinations VALUES (?,?,?,?,?)')
+      .run(input.ownerId, id, input.type, input.version, canonicalJson(input.config).json);
+    return readDestination({ db: this.db, scope: { ...input, id } });
+  }
+  destinations(scope: Scope) {
+    return this.db
+      .query<{ id: string }, [string]>(
+        'SELECT id FROM destinations WHERE owner_id=? ORDER BY rowid',
+      )
+      .all(scope.ownerId)
+      .map(({ id }) => readDestination({ db: this.db, scope: { ...scope, id } }));
+  }
+  createInstallation(input: CreateInstallation & { initialCheckpoint: JsonValue }) {
+    const id = `sync_${crypto.randomUUID()}`;
+    this.db
+      .transaction(() => {
+        readDestination({ db: this.db, scope: { ...input, id: input.destinationId } });
+        this.db
+          .query(`INSERT INTO installations (owner_id,id,source_id,definition_id,definition_version,artifact_id,connection,config,destination_id,enabled,checkpoint,interval_ms,next_due_at,status)
+        VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)`)
+          .run(
+            input.ownerId,
+            id,
+            `source_${crypto.randomUUID()}`,
+            input.definition.id,
+            input.definition.version,
+            input.definition.artifactId,
+            input.connection ? canonicalJson(input.connection).json : null,
+            canonicalJson(input.config).json,
+            input.destinationId,
+            Number(input.enabled ?? true),
+            canonicalJson(input.initialCheckpoint).json,
+            input.intervalMs ?? defaultTiming.leaseMs,
+            Date.now(),
+            input.enabled === false ? 'disabled' : 'ready',
+          );
+      })
+      .immediate();
+    return this.installation({ ...input, id });
+  }
+  installation(input: Resource) {
+    return readInstallation({ db: this.db, scope: input });
+  }
+  installations(scope: Scope) {
+    return this.db
+      .query<{ id: string }, [string]>(
+        'SELECT id FROM installations WHERE owner_id=? ORDER BY rowid',
+      )
+      .all(scope.ownerId)
+      .map(({ id }) => this.installation({ ...scope, id }));
+  }
+  runs(input: Resource & { offset: number }) {
+    this.installation(input);
+    const limit = 50;
+    const rows = this.db
+      .query<
+        {
+          id: string;
+          state: string;
+          started_at: number;
+          completed_at: number | null;
+          pages: number;
+          checkpoint_revision: number;
+        },
+        [string, string, number, number]
+      >(
+        'SELECT id,state,started_at,completed_at,pages,checkpoint_revision FROM runs WHERE owner_id=? AND installation_id=? ORDER BY started_at DESC,rowid DESC LIMIT ? OFFSET ?',
+      )
+      .all(input.ownerId, input.id, limit + 1, input.offset);
+    return {
+      runs: rows.slice(0, limit).map((row) => ({
+        id: row.id,
+        state: row.state,
+        startedAt: row.started_at,
+        completedAt: row.completed_at,
+        pages: row.pages,
+        checkpointRevision: row.checkpoint_revision,
+      })),
+      hasMore: rows.length > limit,
+      pageSize: limit,
+    };
+  }
+  setEnabled(input: Resource & { enabled: boolean }) {
+    return this.db
+      .transaction(() => {
+        this.installation(input);
+        this.db
+          .query(
+            'UPDATE installations SET enabled=?,binding_epoch=binding_epoch+1,status=?,next_due_at=? WHERE owner_id=? AND id=?',
+          )
+          .run(
+            Number(input.enabled),
+            input.enabled ? 'ready' : 'disabled',
+            Date.now(),
+            input.ownerId,
+            input.id,
+          );
+        this.db
+          .query(
+            "UPDATE runs SET state='cancelled',completed_at=? WHERE owner_id=? AND installation_id=? AND state='running'",
+          )
+          .run(Date.now(), input.ownerId, input.id);
+        return this.installation(input);
+      })
+      .immediate();
+  }
+  queue(input: Resource & { checkpoint?: JsonValue }): void {
+    this.db
+      .transaction(() => {
+        if (!this.installation(input).enabled) {
+          fail('disabled');
+        }
+        if (
+          this.db
+            .query("SELECT 1 FROM runs WHERE owner_id=? AND installation_id=? AND state='running'")
+            .get(input.ownerId, input.id)
+        ) {
+          fail('busy');
+        }
+        if (input.checkpoint !== undefined) {
+          this.db
+            .query(
+              'UPDATE installations SET checkpoint=?,checkpoint_revision=checkpoint_revision+1 WHERE owner_id=? AND id=?',
+            )
+            .run(canonicalJson(input.checkpoint).json, input.ownerId, input.id);
+        }
+        this.db
+          .query("UPDATE installations SET next_due_at=?,status='ready' WHERE owner_id=? AND id=?")
+          .run(Date.now(), input.ownerId, input.id);
+      })
+      .immediate();
+  }
+}

package/src/repositories/delivery/contract.ts

@@ -0,0 +1,23 @@
+import type {
+  Delivery,
+  DeliveryPage,
+  DeliveryResult,
+  Destination,
+  QueueStatus,
+} from '../../models/delivery';
+import type { Resource, Scope } from '../../models/identity';
+
+export interface DeliveryLease extends Scope {
+  delivery: Delivery;
+  destination: Destination;
+  workerId: string;
+  generation: number;
+  attempt: number;
+}
+export interface DeliveryRepository {
+  claim(leaseMs: number): DeliveryLease | undefined;
+  complete(input: { lease: DeliveryLease; result: DeliveryResult; delay: number }): void;
+  status(scope: Scope): QueueStatus;
+  pending(input: Scope & { offset: number }): DeliveryPage;
+  retry(input: Resource): void;
+}

package/src/repositories/delivery/sqlite.ts

@@ -0,0 +1,111 @@
+import type { Database } from 'bun:sqlite';
+import type { DeliveryResult, PendingDelivery } from '../../models/delivery';
+import { fail } from '../../models/error';
+import { type Resource, type Scope, workerScope } from '../../models/identity';
+import { queueUsage } from '../queue-usage';
+import { type Row, readDestination } from '../rows';
+import type { DeliveryLease, DeliveryRepository } from './contract';
+
+export class SqliteDeliveries implements DeliveryRepository {
+  constructor(private readonly db: Database) {}
+  claim(leaseMs: number): DeliveryLease | undefined {
+    return this.db
+      .transaction(() => {
+        // A blocked delivery stops only its destination; ordering survives retries and restarts.
+        const row = this.db
+          .query<
+            Row,
+            [number, number]
+          >(`SELECT d.* FROM deliveries d WHERE d.state!='blocked' AND d.due_at<=?
+        AND (d.state='pending' OR d.expires_at<=?) AND NOT EXISTS (
+          SELECT 1 FROM deliveries prior WHERE prior.owner_id=d.owner_id AND prior.destination_id=d.destination_id AND prior.sequence<d.sequence)
+        ORDER BY d.sequence LIMIT 1`)
+          .get(Date.now(), Date.now());
+        if (!row) {
+          return;
+        }
+        const workerId = crypto.randomUUID();
+        const scope = workerScope(String(row.owner_id));
+        this.db
+          .query(
+            "UPDATE deliveries SET state='leased',worker_id=?,generation=generation+1,attempt=attempt+1,expires_at=? WHERE owner_id=? AND id=?",
+          )
+          .run(workerId, Date.now() + leaseMs, scope.ownerId, row.id!);
+        return {
+          ...scope,
+          delivery: JSON.parse(String(row.body)),
+          destination: readDestination({
+            db: this.db,
+            scope: { ...scope, id: String(row.destination_id) },
+          }),
+          workerId,
+          generation: Number(row.generation) + 1,
+          attempt: Number(row.attempt) + 1,
+        };
+      })
+      .immediate();
+  }
+  complete(input: { lease: DeliveryLease; result: DeliveryResult; delay: number }): void {
+    const { lease, result } = input;
+    this.db
+      .transaction(() => {
+        if (
+          !this.db
+            .query(
+              "SELECT 1 FROM deliveries WHERE owner_id=? AND id=? AND state='leased' AND worker_id=? AND generation=? AND expires_at>?",
+            )
+            .get(lease.ownerId, lease.delivery.id, lease.workerId, lease.generation, Date.now())
+        ) {
+          fail('lease_lost');
+        }
+        if (result.status === 'accepted') {
+          this.db
+            .query('DELETE FROM deliveries WHERE owner_id=? AND id=?')
+            .run(lease.ownerId, lease.delivery.id);
+          // Capacity is global; all paused acquisitions can compete for the released budget.
+          this.db
+            .query(
+              "UPDATE installations SET next_due_at=? WHERE enabled=1 AND status='waiting_for_capacity'",
+            )
+            .run(Date.now());
+        } else {
+          this.db
+            .query(
+              'UPDATE deliveries SET state=?,due_at=?,worker_id=NULL,expires_at=NULL,error_code=? WHERE owner_id=? AND id=?',
+            )
+            .run(
+              result.status === 'rejected' ? 'blocked' : 'pending',
+              Date.now() + input.delay,
+              result.code ?? null,
+              lease.ownerId,
+              lease.delivery.id,
+            );
+        }
+      })
+      .immediate();
+  }
+  status(scope: Scope) {
+    return queueUsage({ db: this.db, ownerId: scope.ownerId });
+  }
+  pending(input: Scope & { offset: number }) {
+    const limit = 50;
+    const rows = this.db
+      .query<
+        PendingDelivery,
+        [string, number, number]
+      >(`SELECT id,installation_id AS installationId,destination_id AS destinationId,state,bytes,
+      record_count AS recordCount,attempt,due_at AS nextAttemptAt,error_code AS errorCode FROM deliveries WHERE owner_id=? ORDER BY sequence LIMIT ? OFFSET ?`)
+      .all(input.ownerId, limit + 1, input.offset);
+    return { deliveries: rows.slice(0, limit), hasMore: rows.length > limit, pageSize: limit };
+  }
+  retry(input: Resource): void {
+    const updated = this.db
+      .query(
+        "UPDATE deliveries SET state='pending',due_at=?,generation=generation+1,worker_id=NULL,expires_at=NULL,error_code=NULL WHERE owner_id=? AND id=?",
+      )
+      .run(Date.now(), input.ownerId, input.id);
+    if (!updated.changes) {
+      fail('not_found');
+    }
+  }
+}

package/src/repositories/providers/contract.ts

@@ -0,0 +1,15 @@
+import type {
+  ProviderAuthorization,
+  ProviderConnection,
+  ProviderScope,
+} from '../../models/providers';
+
+export interface ProviderRepository {
+  list(scope: ProviderScope): Promise<ProviderConnection[]>;
+  connection(input: ProviderScope & { id: string }): Promise<ProviderConnection | null>;
+  owns(input: ProviderScope & { connectorId: string }): Promise<boolean>;
+  start(input: ProviderScope & ProviderAuthorization): Promise<void>;
+  pending(input: ProviderScope & { id: string }): Promise<ProviderAuthorization | null>;
+  add(input: ProviderScope & ProviderConnection): Promise<void>;
+  complete(input: ProviderScope & ProviderConnection): Promise<void>;
+}

package/src/repositories/providers/sqlite.ts

@@ -0,0 +1,79 @@
+import type { Database } from 'bun:sqlite';
+import type {
+  ProviderAuthorization,
+  ProviderConnection,
+  ProviderScope,
+} from '../../models/providers';
+import type { ProviderRepository } from './contract';
+
+// This database contains only Open Sync's ownership references, never provider credentials.
+export class SqliteProviders implements ProviderRepository {
+  constructor(private readonly db: Database) {}
+  list(scope: ProviderScope) {
+    return Promise.resolve(
+      this.db
+        .query<ProviderConnection, [string]>(
+          'SELECT id, connector_id AS connectorId, account, service FROM provider_connections WHERE owner_id=? ORDER BY id',
+        )
+        .all(scope.ownerId),
+    );
+  }
+  connection(input: ProviderScope & { id: string }) {
+    return Promise.resolve(
+      this.db
+        .query<ProviderConnection, [string, string]>(
+          'SELECT id, connector_id AS connectorId, account, service FROM provider_connections WHERE owner_id=? AND id=?',
+        )
+        .get(input.ownerId, input.id),
+    );
+  }
+  owns(input: ProviderScope & { connectorId: string }) {
+    return Promise.resolve(
+      Boolean(
+        this.db
+          .query('SELECT id FROM provider_connections WHERE owner_id=? AND connector_id=?')
+          .get(input.ownerId, input.connectorId),
+      ),
+    );
+  }
+  start(input: ProviderScope & ProviderAuthorization) {
+    this.db
+      .query(`INSERT INTO provider_authorizations(owner_id,id,request_id,service) VALUES (?,?,?,?)
+      ON CONFLICT(owner_id) DO UPDATE SET id=excluded.id,request_id=excluded.request_id,service=excluded.service`)
+      .run(input.ownerId, input.id, input.requestId, input.service);
+    return Promise.resolve();
+  }
+  pending(input: ProviderScope & { id: string }) {
+    return Promise.resolve(
+      this.db
+        .query<ProviderAuthorization, [string, string]>(
+          'SELECT id,request_id AS requestId,service FROM provider_authorizations WHERE owner_id=? AND id=?',
+        )
+        .get(input.ownerId, input.id),
+    );
+  }
+  add(input: ProviderScope & ProviderConnection) {
+    this.db
+      .query(
+        'INSERT INTO provider_connections(owner_id,id,connector_id,account,service) VALUES (?,?,?,?,?)',
+      )
+      .run(input.ownerId, input.id, input.connectorId, input.account, input.service);
+    return Promise.resolve();
+  }
+  complete(input: ProviderScope & ProviderConnection) {
+    this.db
+      .transaction(() => {
+        // A superseded authorization must never claim a connection.
+        this.db
+          .query(`INSERT INTO provider_connections(owner_id,id,connector_id,account,service)
+        SELECT owner_id,id,?,?,? FROM provider_authorizations WHERE owner_id=? AND id=?
+        ON CONFLICT(owner_id,id) DO NOTHING`)
+          .run(input.connectorId, input.account, input.service, input.ownerId, input.id);
+        this.db
+          .query('DELETE FROM provider_authorizations WHERE owner_id=? AND id=?')
+          .run(input.ownerId, input.id);
+      })
+      .immediate();
+    return Promise.resolve();
+  }
+}

package/src/repositories/queue-usage.ts

@@ -0,0 +1,21 @@
+import type { Database } from 'bun:sqlite';
+import type { QueueStatus } from '../models/delivery';
+import type { QueueLimits } from '../models/limits';
+export function queueUsage(input: { db: Database; ownerId?: string }): QueueStatus {
+  const row = input.db
+    .query<
+      QueueStatus,
+      [string | null, string | null]
+    >(`SELECT coalesce(sum(bytes),0) AS pendingBytes,
+    coalesce(sum(record_count),0) AS pendingRecords,count(*) AS pendingDeliveries,
+    coalesce(sum(state='blocked'),0) AS blockedDeliveries FROM deliveries WHERE (? IS NULL OR owner_id=?)`)
+    .get(input.ownerId ?? null, input.ownerId ?? null)!;
+  return row;
+}
+export function hasQueueCapacity(input: { db: Database; limits: QueueLimits }): boolean {
+  const usage = queueUsage({ db: input.db });
+  return (
+    usage.pendingBytes < input.limits.maxPendingBytes &&
+    usage.pendingRecords < input.limits.maxPendingRecords
+  );
+}

package/src/repositories/rows.ts

@@ -0,0 +1,50 @@
+import type { Database } from 'bun:sqlite';
+import type { Destination } from '../models/delivery';
+import { fail } from '../models/error';
+import type { Resource } from '../models/identity';
+import type { Installation } from '../models/installation';
+
+export type Row = Record<string, string | number | null>;
+export function readInstallation(input: { db: Database; scope: Resource }): Installation {
+  const row = input.db
+    .query<Row, [string, string]>('SELECT * FROM installations WHERE owner_id=? AND id=?')
+    .get(input.scope.ownerId, input.scope.id);
+  if (!row) {
+    fail('not_found');
+  }
+  return {
+    id: String(row.id),
+    ownerId: String(row.owner_id),
+    sourceId: String(row.source_id),
+    definition: {
+      id: String(row.definition_id),
+      version: String(row.definition_version),
+      artifactId: String(row.artifact_id),
+    },
+    connection: row.connection === null ? undefined : JSON.parse(String(row.connection)),
+    config: JSON.parse(String(row.config)),
+    destinationId: String(row.destination_id),
+    enabled: row.enabled === 1,
+    bindingEpoch: Number(row.binding_epoch),
+    checkpoint: JSON.parse(String(row.checkpoint)),
+    checkpointRevision: Number(row.checkpoint_revision),
+    intervalMs: Number(row.interval_ms),
+    nextDueAt: Number(row.next_due_at),
+    status: String(row.status),
+  };
+}
+export function readDestination(input: { db: Database; scope: Resource }): Destination {
+  const row = input.db
+    .query<Row, [string, string]>('SELECT * FROM destinations WHERE owner_id=? AND id=?')
+    .get(input.scope.ownerId, input.scope.id);
+  if (!row) {
+    fail('not_found');
+  }
+  return {
+    id: String(row.id),
+    ownerId: String(row.owner_id),
+    type: String(row.type),
+    version: String(row.version),
+    config: JSON.parse(String(row.config)),
+  };
+}

package/src/runtime.ts

@@ -0,0 +1,90 @@
+import { openDatabase } from './db/client';
+import { type Logger, safeLogger } from './execution/diagnostics';
+import type { ProviderGateway } from './execution/provider';
+import { Worker } from './execution/worker';
+import type { SyncRegistration } from './models/definition';
+import type { DestinationType } from './models/delivery';
+import { fail } from './models/error';
+import {
+  defaultLimits,
+  defaultTiming,
+  positive,
+  type QueueLimits,
+  type Timing,
+} from './models/limits';
+import { Registry } from './models/registry';
+import { SqliteAcquisition } from './repositories/acquisition/sqlite';
+import { SqliteCatalog } from './repositories/catalog/sqlite';
+import { SqliteDeliveries } from './repositories/delivery/sqlite';
+import { AcquisitionService } from './services/acquisition';
+import { DeliveryService } from './services/delivery';
+import { SyncManagement } from './services/management';
+
+export interface SyncRuntimeOptions {
+  databasePath: string;
+  definitions: readonly SyncRegistration[];
+  destinationTypes: Readonly<Record<string, DestinationType>>;
+  connector?: ProviderGateway;
+  limits?: Partial<QueueLimits>;
+  timing?: Partial<Timing>;
+  onEvent?: Logger;
+}
+/** Bun headless composition root. The host owns listeners, authentication and process lifecycle. */
+export function createSyncRuntime(options: SyncRuntimeOptions) {
+  const timing = { ...defaultTiming, ...options.timing };
+  const limits = { ...defaultLimits, ...options.limits };
+  for (const value of [...Object.values(timing), ...Object.values(limits)]) {
+    positive(value);
+  }
+  if (timing.timeoutMs >= timing.leaseMs) {
+    fail('timeout_must_be_shorter_than_lease');
+  }
+  const registry = new Registry({
+    definitions: options.definitions,
+    destinations: options.destinationTypes,
+  });
+  const db = openDatabase(options.databasePath);
+  try {
+    const catalog = new SqliteCatalog(db);
+    for (const definition of registry.definitions()) {
+      catalog.register(definition);
+    }
+    const deliveries = new SqliteDeliveries(db);
+    const log = safeLogger(options.onEvent);
+    const worker = new Worker({
+      acquisition: new AcquisitionService({
+        repository: new SqliteAcquisition({ db, limits, historyLimit: timing.historyLimit }),
+        registry,
+        gateway: options.connector,
+        timing,
+        log,
+      }),
+      delivery: new DeliveryService({ repository: deliveries, registry, timing }),
+      timing,
+      log,
+    });
+    const api = new SyncManagement({
+      catalog,
+      deliveries,
+      registry,
+      worker,
+      gateway: options.connector,
+      limits,
+      timeoutMs: timing.timeoutMs,
+    });
+    let closing: Promise<void> | undefined;
+    return {
+      api,
+      start: () => worker.start(),
+      tick: () => worker.tick(),
+      close: () => {
+        closing ??= worker.close().finally(() => db.close());
+        return closing;
+      },
+    };
+  } catch (error) {
+    db.close();
+    throw error;
+  }
+}
+export type SyncRuntime = ReturnType<typeof createSyncRuntime>;