@powersync/service-core 1.24.0 → 1.26.0

package/test/src/routes/admin.test.ts

@@ -34,6 +34,7 @@ describe('admin routes', () => {
     syncConfigId?: string;
     active?: boolean;
     content?: string;
+    version_label?: string;
   }): storage.PersistedSyncConfigContent {
     const id = options.id ?? 1;
     const syncConfigId = options.syncConfigId ?? String(id);
@@ -66,6 +67,7 @@ bucket_definitions:
       compiled_plan: null,
       storageVersion: storage.LEGACY_STORAGE_VERSION,
       syncConfigState: syncConfigStatus.state,
+      version_label: options.version_label,
       parsed(options?: any) {
         const syncRules = SqlSyncRules.fromYaml(content.sync_rules_content, {
           ...options,
@@ -113,7 +115,7 @@ bucket_definitions:
 
   describe('diagnostics', () => {
     it('returns deploying config status', async () => {
-      const active = makeSyncConfigContent({ id: 1, syncConfigId: 'active-config' });
+      const active = makeSyncConfigContent({ id: 1, syncConfigId: 'active-config', version_label: 'v5' });
       const deploying = makeSyncConfigContent({ id: 2, syncConfigId: 'deploying-config', active: false });
       const getInstance = vi.fn(() => ({
         async getStatus() {
@@ -144,12 +146,13 @@ bucket_definitions:
 
       expect(response.deploying_sync_rules?.connections[0].slot_name).toBe('slot_2');
       expect(response.active_sync_rules?.connections[0].slot_name).toBe('slot_1');
+      expect(response.active_sync_rules?.version_label).toBe('v5');
     });
   });
 
   describe('reprocess', () => {
     it('reprocesses the active sync config', async () => {
-      const active = makeSyncConfigContent({ id: 7, syncConfigId: 'active-config' });
+      const active = makeSyncConfigContent({ id: 7, syncConfigId: 'active-config', version_label: 'v6' });
       const updateSyncRules = vi.fn(async () => ({
         replicationStreamId: 8,
         replicationStreamName: 'new_slot',
@@ -178,6 +181,9 @@ bucket_definitions:
       expect(activeBucketStorage.getActiveSyncConfig).toHaveBeenCalledTimes(1);
       expect(activeBucketStorage.getSyncConfigContent).not.toHaveBeenCalled();
       expect(updateSyncRules).toHaveBeenCalledTimes(1);
+      expect(updateSyncRules).toHaveBeenCalledWith(
+        expect.objectContaining({ version_label: 'v6', forceNewReplicationStream: true })
+      );
       expect(response.connections[0].slot_name).toBe('new_slot');
     });
 

package/test/src/routes/stream.test.ts

@@ -1,4 +1,12 @@
-import { BasicRouterRequest, Context, JwtPayload, SyncRulesBucketStorage } from '@/index.js';
+import {
+  BasicRouterRequest,
+  CHECKPOINT_INVALIDATE_ALL,
+  Context,
+  JwtPayload,
+  RequestTracker,
+  streamResponse,
+  SyncRulesBucketStorage
+} from '@/index.js';
 import { logger, RouterResponse, ServiceError } from '@powersync/lib-services-framework';
 import {
   DEFAULT_HYDRATION_STATE,
@@ -9,7 +17,7 @@ import {
 import * as sqlite from 'node:sqlite';
 import { Readable, Writable } from 'stream';
 import { pipeline } from 'stream/promises';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import winston from 'winston';
 import { syncStreamed } from '../../../src/routes/endpoints/sync-stream.js';
 import { DEFAULT_PARAM_LOGGING_FORMAT_OPTIONS, limitParamsForLogging } from '../../../src/util/param-logging.js';
@@ -182,6 +190,119 @@ describe('Stream Route', () => {
       );
     });
   });
+
+  it('closes after a data fetch error while waiting for a new checkpoint', async () => {
+    // After 1,000 operations, the sync stream concurrently calls next() on the
+    // checkpoint watcher. This test then fails the next data fetch without
+    // producing another checkpoint. Before the fix, awaiting watcher.return()
+    // during cleanup queued it behind that pending next(), leaving the response
+    // open until an unrelated checkpoint was written.
+    const syncRules = SqlSyncRules.fromYaml(
+      `
+bucket_definitions:
+  global:
+    data: []
+      `,
+      { defaultSchema: 'public' }
+    ).config.hydrate(defaultHydrationOptions);
+
+    let checkpointWatcherAborted = false;
+    let dataFetches = 0;
+    const storage = {
+      watchCheckpointChanges: async function* ({ signal }) {
+        yield {
+          base: {
+            checkpoint: 1n,
+            lsn: '1',
+            getParameterSets: async () => []
+          },
+          writeCheckpoint: null,
+          update: CHECKPOINT_INVALIDATE_ALL
+        };
+
+        await new Promise<void>((_resolve, reject) => {
+          // There is intentionally no next checkpoint: cleanup must abort this
+          // pending wait rather than wait for it to complete naturally.
+          signal.addEventListener(
+            'abort',
+            () => {
+              checkpointWatcherAborted = true;
+              reject(new Error('Checkpoint watcher aborted'));
+            },
+            { once: true }
+          );
+        });
+      },
+      getChecksums: async (_checkpoint, buckets) =>
+        new Map(buckets.map(({ bucket }) => [bucket, { bucket, checksum: 1, count: 1000 }])),
+      getBucketDataBatch: async function* () {
+        if (dataFetches++ > 0) {
+          throw new Error('Simulated data fetch failure');
+        }
+
+        yield {
+          chunkData: {
+            bucket: 'global[]',
+            data: Array.from({ length: 1000 }, () => ({ op: 'PUT' })),
+            has_more: true,
+            after: '0',
+            next_after: '1000'
+          },
+          targetOp: null
+        };
+        yield { hasMore: true };
+      }
+    } as Partial<SyncRulesBucketStorage>;
+    const serviceContext = mockServiceContext(storage);
+    const controller = new AbortController();
+    const checkpointLogger = logger.child({});
+    const checkpointLogSpy = vi.spyOn(checkpointLogger, 'info');
+
+    const response = (async () => {
+      for await (const _line of streamResponse({
+        syncContext: serviceContext.syncContext,
+        bucketStorage: storage as SyncRulesBucketStorage,
+        syncRules,
+        params: { client_id: 'test-client', raw_data: true },
+        token: new JwtPayload({ sub: 'test-user', exp: Date.now() / 1000 + 10_000 }),
+        tracker: new RequestTracker(serviceContext.metricsEngine),
+        isEncodingAsBson: false,
+        signal: controller.signal,
+        logger: checkpointLogger
+      })) {
+        // Consume the response until the simulated data fetch error is propagated.
+      }
+    })();
+
+    let timeout: NodeJS.Timeout | undefined;
+    const outcome = await Promise.race([
+      response.then(
+        () => new Error('Sync stream unexpectedly completed'),
+        (error) => error
+      ),
+      new Promise((resolve) => {
+        timeout = setTimeout(() => resolve(new Error('Sync stream did not close')), 500);
+      })
+    ]);
+    clearTimeout(timeout);
+
+    // Capture this before aborting below, which would set it regardless of the stream cleanup.
+    const abortedByCleanup = checkpointWatcherAborted;
+
+    controller.abort();
+    await response.catch(() => {});
+
+    expect(outcome).toBeInstanceOf(Error);
+    expect((outcome as Error).message).toContain('Simulated data fetch failure');
+    expect(abortedByCleanup).toBe(true);
+    expect(checkpointLogSpy).toHaveBeenCalledWith('checkpoint_interrupted: 1', {
+      checkpoint: 1n,
+      user_id: 'test-user',
+      operations_synced: 1000,
+      data_synced_bytes: 0,
+      ms: expect.any(Object)
+    });
+  });
 });
 
 export async function drainWithTimeout(readable: Readable, ms = 2_000) {

package/test/src/source-table-reconciler.test.ts

@@ -0,0 +1,244 @@
+import { SourceEntityDescriptor } from '@/storage/SourceEntity.js';
+import { SourceTable, sourceTableIdEquals } from '@/storage/SourceTable.js';
+import {
+  defaultSourceTableReconciler,
+  diffSourceTableUpdates,
+  materializeSourceTableResolution,
+  sourceIdentityCompatible,
+  validateSourceTableCandidateResolution
+} from '@/storage/SourceTableReconciler.js';
+import * as bson from 'bson';
+import { describe, expect, it } from 'vitest';
+
+function descriptor(overrides: Partial<SourceEntityDescriptor> = {}): SourceEntityDescriptor {
+  return {
+    connectionTag: 'default',
+    schema: 'public',
+    name: 'users',
+    objectId: 100,
+    replicaIdColumns: [{ name: 'id', type: 'int', typeId: 23 }],
+    ...overrides
+  };
+}
+
+function candidate(overrides: Partial<ConstructorParameters<typeof SourceTable>[0]> = {}): SourceTable {
+  return new SourceTable({
+    id: overrides.id ?? 'table-1',
+    ref: overrides.ref ?? { connectionTag: 'default', schema: 'public', name: 'users' },
+    objectId: 'objectId' in overrides ? overrides.objectId! : 100,
+    replicaIdColumns: overrides.replicaIdColumns ?? [{ name: 'id', type: 'int', typeId: 23 }],
+    snapshotComplete: overrides.snapshotComplete ?? true,
+    bucketDataSources: overrides.bucketDataSources ?? [],
+    parameterLookupSources: overrides.parameterLookupSources ?? [],
+    sourceMetadata: overrides.sourceMetadata
+  });
+}
+
+describe('sourceIdentityCompatible', () => {
+  it('matches identical identity', () => {
+    expect(sourceIdentityCompatible(descriptor(), candidate())).toBe(true);
+  });
+
+  it('rejects a different object id', () => {
+    expect(sourceIdentityCompatible(descriptor({ objectId: 200 }), candidate({ objectId: 100 }))).toBe(false);
+  });
+
+  it('rejects a different schema/name', () => {
+    expect(sourceIdentityCompatible(descriptor({ name: 'accounts' }), candidate())).toBe(false);
+  });
+
+  it('rejects changed replica-id columns', () => {
+    expect(
+      sourceIdentityCompatible(
+        descriptor(),
+        candidate({ replicaIdColumns: [{ name: 'id', type: 'bigint', typeId: 20 }] })
+      )
+    ).toBe(false);
+  });
+
+  it('treats an undefined descriptor object id as a wildcard on object id', () => {
+    expect(sourceIdentityCompatible(descriptor({ objectId: undefined }), candidate({ objectId: 999 }))).toBe(true);
+  });
+});
+
+describe('defaultSourceTableReconciler', () => {
+  it('returns all identity-compatible candidates and no metadata', async () => {
+    const a = candidate({ id: 'a' });
+    const b = candidate({ id: 'b', ref: { connectionTag: 'default', schema: 'public', name: 'accounts' } });
+    const resolution = await defaultSourceTableReconciler({ source: descriptor(), candidates: [a, b] });
+    expect(resolution.compatibleTables).toEqual([a]);
+    expect(resolution.incompatibleTables).toEqual([b]);
+    expect(resolution.newTableValues).toEqual({ sourceMetadata: null });
+  });
+
+  it('returns an empty set when nothing matches', async () => {
+    const resolution = await defaultSourceTableReconciler({
+      source: descriptor({ objectId: 200 }),
+      candidates: [candidate({ objectId: 100 })]
+    });
+    expect(resolution.compatibleTables).toHaveLength(0);
+    expect(resolution.incompatibleTables.map((table) => table.id)).toEqual(['table-1']);
+  });
+});
+
+describe('validateSourceTableCandidateResolution', () => {
+  it('accepts an explicit compatible/incompatible partition', () => {
+    const a = candidate({ id: 'a' });
+    const b = candidate({ id: 'b' });
+    expect(() =>
+      validateSourceTableCandidateResolution([a, b], {
+        compatibleTables: [a],
+        incompatibleTables: [b],
+        newTableValues: { sourceMetadata: null }
+      })
+    ).not.toThrow();
+  });
+
+  it('rejects omitted, duplicate, and unknown candidates', () => {
+    const a = candidate({ id: 'a' });
+    expect(() =>
+      validateSourceTableCandidateResolution([a], {
+        compatibleTables: [],
+        incompatibleTables: [],
+        newTableValues: { sourceMetadata: null }
+      })
+    ).toThrow(/exactly once/);
+    expect(() =>
+      validateSourceTableCandidateResolution([a], {
+        compatibleTables: [a],
+        incompatibleTables: [a],
+        newTableValues: { sourceMetadata: null }
+      })
+    ).toThrow(/exactly once/);
+    expect(() =>
+      validateSourceTableCandidateResolution([a], {
+        compatibleTables: [a],
+        incompatibleTables: [candidate({ id: 'unknown' })],
+        newTableValues: { sourceMetadata: null }
+      })
+    ).toThrow(/unknown candidate/);
+  });
+});
+
+describe('diffSourceTableUpdates', () => {
+  function resolution(compatibleTables: SourceTable[]) {
+    return { compatibleTables, incompatibleTables: [], newTableValues: { sourceMetadata: null } };
+  }
+
+  it('returns nothing when the reconciler returned the candidates untouched', () => {
+    const a = candidate({ id: 'a', sourceMetadata: { captureTableObjectId: 7 } });
+    expect(diffSourceTableUpdates([a], resolution([a]))).toEqual([]);
+  });
+
+  it('compares by value, not by reference', () => {
+    // A new object with equal metadata should not cause a write.
+    const a = candidate({ id: 'a', sourceMetadata: { captureTableObjectId: 7 } });
+    const rebuilt = a.withSourceMetadata({ captureTableObjectId: 7 });
+
+    expect(rebuilt.sourceMetadata).not.toBe(a.sourceMetadata);
+    expect(diffSourceTableUpdates([a], resolution([rebuilt]))).toEqual([]);
+  });
+
+  it('returns changed metadata', () => {
+    const a = candidate({ id: 'a', sourceMetadata: { captureTableObjectId: 7 } });
+    expect(diffSourceTableUpdates([a], resolution([a.withSourceMetadata({ captureTableObjectId: 8 })]))).toEqual([
+      { id: 'a', sourceMetadata: { captureTableObjectId: 8 } }
+    ]);
+  });
+
+  it('returns metadata added to a legacy record', () => {
+    const legacy = candidate({ id: 'a' });
+    expect(legacy.sourceMetadata).toBeNull();
+    expect(
+      diffSourceTableUpdates([legacy], resolution([legacy.withSourceMetadata({ captureTableObjectId: 7 })]))
+    ).toEqual([{ id: 'a', sourceMetadata: { captureTableObjectId: 7 } }]);
+  });
+
+  it('returns cleared metadata as null', () => {
+    const a = candidate({ id: 'a', sourceMetadata: { captureTableObjectId: 7 } });
+    expect(diffSourceTableUpdates([a], resolution([a.withSourceMetadata(null)]))).toEqual([
+      { id: 'a', sourceMetadata: null }
+    ]);
+  });
+
+  it('materializes only source metadata from reconciler results', () => {
+    const persisted = candidate({ id: 'a', snapshotComplete: false });
+    const modified = persisted.withSourceMetadata({ captureTableObjectId: 8 });
+    modified.snapshotComplete = true;
+    modified.syncData = false;
+
+    const [materialized] = materializeSourceTableResolution([persisted], resolution([modified])).compatibleTables;
+
+    expect(materialized.sourceMetadata).toEqual({ captureTableObjectId: 8 });
+    expect(materialized.snapshotComplete).toBe(false);
+    expect(materialized.syncData).toBe(persisted.syncData);
+  });
+
+  it('does not trust incompatible candidate mutations made through a cast', () => {
+    const persisted = candidate({ id: 'a', snapshotComplete: false });
+    const exposed = persisted.clone();
+    // Simulate callback code bypassing the read-only type boundary.
+    (exposed as any).snapshotComplete = true;
+
+    const materialized = materializeSourceTableResolution([persisted], {
+      compatibleTables: [],
+      incompatibleTables: [exposed],
+      newTableValues: { sourceMetadata: null }
+    }).incompatibleTables[0];
+
+    expect(exposed.snapshotComplete).toBe(true);
+    expect(materialized).toBe(persisted);
+    expect(materialized.snapshotComplete).toBe(false);
+    expect(materialized.syncData).toBe(persisted.syncData);
+  });
+
+  it('only reports the candidates that changed', () => {
+    const a = candidate({ id: 'a', sourceMetadata: { captureTableObjectId: 7 } });
+    const b = candidate({ id: 'b', sourceMetadata: { captureTableObjectId: 7 } });
+    const updates = diffSourceTableUpdates([a, b], resolution([a, b.withSourceMetadata({ captureTableObjectId: 9 })]));
+    expect(updates).toEqual([{ id: 'b', sourceMetadata: { captureTableObjectId: 9 } }]);
+  });
+
+  it('rejects a compatible table that was never a candidate', () => {
+    expect(() => diffSourceTableUpdates([candidate({ id: 'a' })], resolution([candidate({ id: 'ghost' })]))).toThrow(
+      /unknown candidate/
+    );
+  });
+});
+
+describe('SourceTable.clone', () => {
+  it('isolates mutable identity and metadata values', () => {
+    const persisted = candidate({ id: 'a', sourceMetadata: { captureTableObjectId: 7 } });
+    const exposed = persisted.clone();
+
+    (exposed.ref as any).name = 'changed';
+    exposed.replicaIdColumns[0].name = 'changed';
+    (exposed.sourceMetadata as any).captureTableObjectId = 8;
+
+    expect(persisted.name).toBe('users');
+    expect(persisted.replicaIdColumns[0].name).toBe('id');
+    expect(persisted.sourceMetadata).toEqual({ captureTableObjectId: 7 });
+  });
+});
+
+describe('sourceTableIdEquals', () => {
+  it('compares string ids by value', () => {
+    expect(sourceTableIdEquals('table-1', 'table-1')).toBe(true);
+    expect(sourceTableIdEquals('table-1', 'table-2')).toBe(false);
+  });
+
+  it('compares BSON ObjectIds by value', () => {
+    const id = new bson.ObjectId();
+    const copy = new bson.ObjectId(id.toHexString());
+
+    expect(id).not.toBe(copy);
+    expect(sourceTableIdEquals(id, copy)).toBe(true);
+  });
+
+  it('does not mix string and BSON ObjectId representations', () => {
+    const id = new bson.ObjectId();
+
+    expect(sourceTableIdEquals(id.toHexString(), id)).toBe(false);
+    expect(sourceTableIdEquals(id, id.toHexString())).toBe(false);
+  });
+});

package/test/src/storage/SourceTable.test.ts

@@ -43,7 +43,8 @@ describe('SourceTable', () => {
     test('clone preserves all properties including storeCurrentData', () => {
       const table = makeTable({
         replicaIdColumns: [{ name: 'id', type: 'int4' }],
-        snapshotComplete: false
+        snapshotComplete: false,
+        eventDefinitionIds: new Set(['event-1'])
       });
 
       table.syncData = false;
@@ -63,6 +64,8 @@ describe('SourceTable', () => {
       expect(cloned.syncEvent).toBe(false);
       expect(cloned.storeCurrentData).toBe(false);
       expect(cloned.snapshotStatus).toEqual(table.snapshotStatus);
+      expect(cloned.eventDefinitionIds).toEqual(new Set(['event-1']));
+      expect(cloned.eventDefinitionIds).not.toBe(table.eventDefinitionIds);
     });
   });
 

package/test/src/storage-metrics.test.ts

@@ -0,0 +1,148 @@
+import { MetricsEngine } from '@/metrics/MetricsEngine.js';
+import {
+  MetricMetadata,
+  MetricsFactory,
+  ObservableGauge,
+  ObservableGaugeObservation
+} from '@/metrics/metrics-interfaces.js';
+import { BucketStorageFactory, StorageMetrics, StorageSyncConfigMetrics } from '@/storage/BucketStorageFactory.js';
+import { createCoreStorageMetrics, initializeCoreStorageMetrics } from '@/storage/storage-metrics.js';
+import { StorageMetric } from '@powersync/service-types';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+type ValueProvider = () => Promise<number | ObservableGaugeObservation[] | undefined>;
+
+function testEngine() {
+  const providers = new Map<string, ValueProvider>();
+  const factory: MetricsFactory = {
+    createCounter: () => ({ add: () => {} }),
+    createUpDownCounter: () => ({ add: () => {} }),
+    createObservableGauge: (metadata: MetricMetadata): ObservableGauge => ({
+      setValueProvider: (valueProvider) => providers.set(metadata.name, valueProvider)
+    })
+  };
+  const engine = new MetricsEngine({ factory, disable_telemetry_sharing: true });
+  createCoreStorageMetrics(engine);
+  return { engine, providers };
+}
+
+function syncConfigMetrics(id: string, state: string, bytes: number, versionLabel?: string): StorageSyncConfigMetrics {
+  return {
+    sync_config_id: id,
+    sync_config_state: state,
+    version_label: versionLabel,
+    attributed_bucket_data_bytes: bytes,
+    attributed_parameter_indexes_bytes: bytes,
+    attributed_source_records_bytes: bytes,
+    attributed_object_storage_bytes: bytes
+  };
+}
+
+function storageMetrics(sync_config_metrics: StorageSyncConfigMetrics[]): StorageMetrics {
+  return {
+    operations_size_bytes: 0,
+    parameters_size_bytes: 0,
+    replication_size_bytes: 0,
+    object_storage_size_bytes: 0,
+    sync_config_metrics
+  };
+}
+
+describe('storage metrics', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('reports retired sync configs as zero, then stops reporting them', async () => {
+    let current = storageMetrics([syncConfigMetrics('config-a', 'ACTIVE', 100)]);
+    const storage = {
+      getStorageMetrics: async () => current
+    } as unknown as BucketStorageFactory;
+
+    const { engine, providers } = testEngine();
+    initializeCoreStorageMetrics(engine, storage);
+    const provider = providers.get(StorageMetric.ATTRIBUTED_BUCKET_DATA_BYTES)!;
+
+    expect(await provider()).toEqual([
+      { value: 100, attributes: { sync_config_id: 'config-a', sync_config_state: 'ACTIVE' } }
+    ]);
+
+    // The sync config is pruned. Its series must go to zero rather than keep its last value,
+    // since the SDK carries the last reported value forward under cumulative temporality.
+    current = storageMetrics([syncConfigMetrics('config-b', 'ACTIVE', 50)]);
+    vi.setSystemTime(61_000);
+
+    expect(await provider()).toEqual([
+      { value: 50, attributes: { sync_config_id: 'config-b', sync_config_state: 'ACTIVE' } },
+      { value: 0, attributes: { sync_config_id: 'config-a', sync_config_state: 'ACTIVE' } }
+    ]);
+
+    // Once every reader has had a chance to observe the zero, stop reporting it entirely.
+    vi.setSystemTime(61_000 + 16 * 60_000);
+
+    expect(await provider()).toEqual([
+      { value: 50, attributes: { sync_config_id: 'config-b', sync_config_state: 'ACTIVE' } }
+    ]);
+  });
+
+  it('treats a state transition as a retired attribute set', async () => {
+    let current = storageMetrics([syncConfigMetrics('config-a', 'PROCESSING', 100, 'v1')]);
+    const storage = {
+      getStorageMetrics: async () => current
+    } as unknown as BucketStorageFactory;
+
+    const { engine, providers } = testEngine();
+    initializeCoreStorageMetrics(engine, storage);
+    const provider = providers.get(StorageMetric.ATTRIBUTED_SOURCE_RECORDS_BYTES)!;
+
+    await provider();
+
+    current = storageMetrics([syncConfigMetrics('config-a', 'ACTIVE', 120, 'v1')]);
+    vi.setSystemTime(61_000);
+
+    expect(await provider()).toEqual([
+      {
+        value: 120,
+        attributes: { sync_config_id: 'config-a', sync_config_state: 'ACTIVE', version_label: 'v1' }
+      },
+      {
+        value: 0,
+        attributes: { sync_config_id: 'config-a', sync_config_state: 'PROCESSING', version_label: 'v1' }
+      }
+    ]);
+  });
+
+  it('does not report anything as retired when reading the metrics fails', async () => {
+    let fail = false;
+    const storage = {
+      getStorageMetrics: async () => {
+        if (fail) {
+          throw new Error('storage unavailable');
+        }
+        return storageMetrics([syncConfigMetrics('config-a', 'ACTIVE', 100)]);
+      }
+    } as unknown as BucketStorageFactory;
+
+    const { engine, providers } = testEngine();
+    initializeCoreStorageMetrics(engine, storage);
+    const provider = providers.get(StorageMetric.ATTRIBUTED_OBJECT_STORAGE_BYTES)!;
+
+    await provider();
+
+    fail = true;
+    vi.setSystemTime(61_000);
+    expect(await provider()).toBeUndefined();
+
+    // The failure must not be interpreted as the sync config having been pruned.
+    fail = false;
+    vi.setSystemTime(122_000);
+    expect(await provider()).toEqual([
+      { value: 100, attributes: { sync_config_id: 'config-a', sync_config_state: 'ACTIVE' } }
+    ]);
+  });
+});

package/test/src/sync/util.test.ts

@@ -43,4 +43,19 @@ describe('acquireSemaphoreAbortable', () => {
     // Releasing the semaphore should not invoke resolve again
     release();
   });
+
+  test('does not wait when the signal is already aborted', async () => {
+    const semaphore = new Semaphore(1);
+    const controller = new AbortController();
+
+    // Hold the only slot, so acquiring would block indefinitely.
+    const result = await acquireSemaphoreAbortable(semaphore, controller.signal);
+    expect(result).not.toBe('aborted');
+    const [, release] = result as [number, SemaphoreInterface.Releaser];
+
+    controller.abort();
+    expect(await acquireSemaphoreAbortable(semaphore, controller.signal)).toBe('aborted');
+
+    release();
+  });
 });

package/test/src/util/utils.test.ts

@@ -0,0 +1,23 @@
+import { formatBytes } from '@/index.js';
+import { describe, expect, test } from 'vitest';
+
+describe('formatBytes', () => {
+  test('formats bytes', () => {
+    expect(formatBytes(500)).toBe('500B');
+  });
+
+  test('formats kilobytes', () => {
+    expect(formatBytes(1024)).toBe('1.0KB');
+    expect(formatBytes(1536)).toBe('1.5KB');
+  });
+
+  test('formats megabytes', () => {
+    expect(formatBytes(1024 * 1024)).toBe('1.0MB');
+    expect(formatBytes(1.5 * 1024 * 1024)).toBe('1.5MB');
+  });
+
+  test('formats gigabytes', () => {
+    expect(formatBytes(1024 * 1024 * 1024)).toBe('1.0GB');
+    expect(formatBytes(10.5 * 1024 * 1024 * 1024)).toBe('10.5GB');
+  });
+});